DEV Community: JoeStrout

MiniScript Weekly(ish) News — September 17, 2026

JoeStrout — Thu, 17 Sep 2026 15:14:44 +0000

(Editor's note: sorry for the long delay since the last update... it was a very busy summer! We'll try to get back to a weekly or near-weekly cadence.)

Development Updates

MiniScript 2 is nearing the finish line: Joe shared Preview 9 this week, with a long list of small but important fixes and improvements. He also said the remaining checklist before an official release is basically empty, while still encouraging everyone to keep testing for those sneaky unknown bugs: MiniScript 2.0 preview 9.

The work behind the scenes has been busy too, especially around performance and correctness. Recent fixes include GC tuning, better handling of lists and maps, cleaner error reporting, and a number of compiler/parser edge cases that were uncovered by real-world projects.

Mini Micro 2 and raylib-miniscript also got meaningful updates. The raylib layer now has a Matrix class, a physics engine, and demos like Connect-4 inference, Game of Life, and the new Angry Balls demo. Meanwhile, both Soda and Mini Micro 2 have been rewritten on top of raylib-miniscript and are now in early testing. Here's a screen shot of a game running in Mini Micro 2, using the new Matrix class to run a deep neural network AI:

In a major milestone for MiniScript maturity, GitHub's Linguist library (used to identify the programming language used by each source file) now recognizes MiniScript. Their servers are slowly reclassifying older projects now.

Community Projects

A big shout-out to community members shipping useful tools and experiments! DSlower shared work on The Slow Shell and a buffer file finder, and shellrider posted a small UUIDv4 generator: ms-uuid.

minerobber also helped push the ecosystem forward with language tooling and portability work, including a self-hosting Clojette compiler, a MiniScript classification fix for GitHub Linguist, and other helpful contributions. They also have a handy tip for forcing correct identification of your MiniScript files on GitHub: in .gitattributes, add *.ms linguist-language=MiniScript.

There were also some fun Mini Micro-adjacent demos and projects worth highlighting. Trey Tomes shared micro-bfxr for sound effects generation: micro-bfxr, and machiaworx posted the Steam release of Cry Pic, noting that most of the game is controlled by MiniScript: Cry Pic on Steam.

Discussion Highlights

A lot of the summer’s conversation centered on making MiniScript and Mini Micro more welcoming and more fun to use. Joe floated a Top 10 Mini Micro Most Wanted list, asking what classic game genres the platform still needs; suggestions ranged from text RPGs and music sequencers to networked play and a Mini Micro BBS.

There was also a great thread for beginners who want to understand how programming “thinks.” Joe walked through tokenizing, parsing, and ASTs with a new learner, encouraging them to start small and build confidence one step at a time — a very MiniScript-friendly way to learn.

On the Mini Micro 2 side, testing continues to uncover useful edge cases. Community feedback helped surface memory and GC issues, import behavior, and a few platform-specific quirks, and Joe responded quickly with fixes and follow-up explanations.

Links Worth Checking Out

Thanks for reading, and keep making cool things — we love seeing what you build!

Upcoming Game Jams

These upcoming jams look like a great fit for Mini Micro:

Garbage jam #7 (starts 2026-09-21 12:00:00) — A super low-stress jam built around experimentation, bad art, and having fun makes it a perfect excuse to try a quirky pixel, tile, or text-based idea without worrying about polish.
Untitled Game Jam #133 (starts 2026-09-18 00:00:00) — A flexible, beginner-friendly jam with an open theme vote, any engine allowed, and no heavy technical constraints—great for a quick retro-style prototype or polished 2D game.
GRC GAME JAM (starts 2026-09-17 22:43:48) — A strong retro-leaning jam focused on fun, creativity, and polished gameplay, with the exciting possibility of seeing your game preserved as a ROM and played on a real arcade cabinet.
Beginners' Jam_Autumn 2026 (starts 2026-09-20 12:00:00) — A very beginner-friendly jam with flexible, open-ended themes and no technical demands beyond making a fun free-to-play game, making it an easy fit for Mini Micro projects.
Creature Collector Game Jam (starts 2026-09-21 06:00:00) — A very strong fit for a retro, 2D-friendly jam centered on collecting, raising, and studying creatures, with plenty of room for charming pixel art, simple systems, and creative monster design.
Goose Jam 3 (starts 2026-09-19 21:00:00) — A very approachable low-scope jam with broad freedom to make anything from a tiny video game to a card or roleplaying game, plus flexible interpretation and no engine restrictions.

Mini Micro "10 Most Wanted" Games

JoeStrout — Wed, 16 Sep 2026 14:46:44 +0000

Mini Micro is the neo-retro virtual computer that those of us who grew up in the personal computer era (the 1980s or so) could only dream of. But there's one way in which those Apple IIs, C-64s, and Atari 800s still have Mini Micro beat: there was a lot more software for them.

The Mini Micro software catalog is still regrettably small. It comes with dozens of small demos; and there are 80-ish small games and apps for it, but if we're being honest, most of them are demos, half-finished projects, or weekend game-jam projects. Those are still awesome, and I'm always glad to see them. But on any real computer in the 80s, every year saw dozens of full, deep games you could get lost in for weeks, not to mention productivity software you could use for real work.

Now, for getting real work done in the 21st century, Mini Micro is probably not ideal. You really are better off using Google Sheets and your favorite desktop word processor. But for entertainment, Mini Micro is still a fine environment. And this is where I really wish we had some more fully polished games to choose from. Games like Klondike Solitaire, Galactic Empire, or the several DLC games, but covering other genres. Of particular interest are genres that are hard to find today, because they've been ruined by microtransactions or have simply fallen out of favor.

And so, with no further ado, here is my "top 10" list of games I'd love to see for Mini Micro.

Wizardry/Bard's Tale-Style RPG

Before there were sprawling open worlds, there was the dungeon crawl: a party of adventurers, a first-person view down a stone corridor, and a stack of graph paper next to the keyboard so you could map where you'd been. Wizardry and The Bard's Tale made this one of the biggest genres of the 80s, and a handful of modern games (like Legend of Grimrock or Etrian Odyssey) show it still works. But there are very few of them.

The step-by-step, grid-based view is easy to draw in Mini Micro, which leaves you free to spend your effort where it counts: interesting party building, tactical turn-based combat, clever puzzles and traps, and a dungeon that rewards careful exploration.

Space Combat Game

Few things in 80s gaming felt as cool as sitting in the cockpit of a starfighter. Star Raiders put you there in 1979, with enemy ships swooping across a starfield, a long-range scanner, and damage reports as your systems got shot out one by one. Wing Commander took it further in 1990: its ships were just scaled and rotated bitmaps, not true 3D models, but with a detailed cockpit around them, a wingman on the radio, and a campaign that changed depending on how you flew, it felt like starring in a space movie.

Today's space games tend to be vast 3D simulators, and some of the biggest are now built around selling ships for real money. The tight, arcade-style cockpit dogfight has mostly disappeared. But that faux-3D approach is a great match for Mini Micro, whose sprites can scale and rotate, with the cockpit, radar, and instruments drawn on a display layer in front. It doesn't need realistic physics; it needs the feeling of flying: throttle, afterburners, shields, wingmen, and enemies that bank and weave instead of just flying straight at you.

Pinball Construction Set

Bill Budge's Pinball Construction Set (1983) was a toy as much as a game: drag bumpers, flippers, spinners, and targets onto a blank table, tweak the gravity and elasticity, and then play what you'd built. You could even save your table and give it to your friends.

There are good pinball games today, but almost nothing that makes building your own table this easy and fun. Mini Micro has everything needed: sprites, sound, and a file system for saving and sharing tables. Include a handful of well-designed tables to show what's possible, and then let players go wild.

Lode Runner-ish Puzzle Platformer

Lode Runner (1983) turned the platformer into a puzzle. You can't jump; instead, you collect gold while guards chase you, and your only weapon is digging holes in the brick floor to trap them (or to reach gold below). The holes fill back in a few seconds later, so every level becomes a tense puzzle about timing and route planning. Plenty of puzzle platformers exist today, but the dig-and-trap mechanic has hardly ever been copied.

It shipped with 150 levels and a level editor, and that pairing is worth keeping. Mini Micro's tile display makes both easy. Build a solid set of hand-crafted levels that teach the mechanics and then twist them, and include an editor so players can make and share their own.

Deep Text Adventure/Interactive Fiction

There was a time when text adventures, or "interactive fiction" as it came to be known, was a huge game category. They weren't all fantasy RPGs; there were mysteries, science fiction, and more.

Mini Micro comes with one little mini-adventure among its demos, but you can create your own text adventure using the same core code. Make it deep; make the interactions rich and the characters believable. Give players something they can get lost in.

M.U.L.E.-like Economic Multiplayer Game

There are other economic games today, but none that match the compact, social, board-game-like quality of M.U.L.E. And a big key to its charm was the way it supported up to 4 players around one computer, each with their own game controller.

But don't just copy the original; be inspired by it, but design something new.

Archon-like Strategy/Action Game

Design a game with a Chess-like strategy layer, taking turns moving pieces around on a board; but when two pieces meet, they fight in a real-time arcade battle. The classic example of this is Archon.

This is a weirdly underexplored area, even today.

Deckbuilding Roguelike Game

Modern games like Slay the Spire show how much fun a deck-building game can be, but this is a genre with plenty of room for creativity and innovation. It could be

a space-combat deckbuilder, where cards are maneuvers, weapons, shields, reactor tricks, crew actions;
a wizard-duel game, where you assemble a spellbook and spells interact chemically or elementally;
a heist deckbuilder, where cards represent tools, disguises, contacts, distractions, and escape routes;
a dungeon crawler where your deck literally represents stamina/memory/equipment availability rather than abstract “cards”;
a civilization or kingdom deckbuilder, where cards are policies, buildings, military units, discoveries, etc.

This is probably the most nebulous idea on the list, but the basic idea is a game where the inventory, abilities, or actions you acquire become a shuffled deck, and constructing that deck is the main form of character development.

Musical Toy

Rhythm games are a huge genre, but most of them amount to press the button the screen tells you to press at the right time in order to keep the music playing. A much smaller subgenre gives you a virtual instrument you can actually play, like in Trombone Champ.

Mini Micro is a powerful music machine, with both digitized and synthesized sounds and dynamic control over pitch and volume. So, build a game/toy with an instrument you can actually play, but make it guided and easy enough for non-musicians to have fun too. Maybe organize it around several mini-games that do varying amounts of hand-holding. And you should be able to record and share your compositions, too -- maybe on a global map, like Ocarina by Smule.

Rube Goldberg Game

In The Incredible Machine (1993), each puzzle gave you a goal (get the ball into the basket, turn on the light, launch the rocket) and a bin of odd parts: ramps, conveyor belts, balloons, bowling balls, candles, and a cat who chases the mouse who runs the treadmill. Your job was to arrange the parts into a contraption that does the job. There was also a free-play mode where you could build whatever silly machine you could imagine.

Apart from a sequel or two by the original developers, this genre has been left mostly alone. It suits 2D perfectly, but it does take a real physics simulation, which makes it one of the more challenging projects on this list. A game that nails the feel of the physics and the humor of the parts would be a real gem, and shared puzzles and contraptions would make it even better.

Developers Wanted!

Mini Micro is an amazing platform, but it could be so much more amazing with games like these. You (yes, you) can contribute to the community in an important way by taking the lead! Pick an idea that inspires you, discuss it on the discord, roll up your sleeves, and dig in. Who knows -- your game might become the next big hit that people will be talking about for years!

MiniScript is a recognized language on GitHub!

JoeStrout — Mon, 14 Sep 2026 23:24:58 +0000

It's been a long time, but MiniScript support has finally been added to Linguist, the library that GitHub itself uses to identify what programming language each file is.

That means that when you go to a repo like fathoms-edge, and look at the bottom of the "About" section, it should correctly report that it's mostly (or entirely) written in MiniScript!

Or for a more interesting example, look at this breakdown from the raylib-miniscript project:

Previously, GitHub was quite confused by our .ms files and would classify them as something else. Now it's getting them right.

To get this update accepted to Linguist, we had to show an active, thriving MiniScript community with a lot of MiniScript code on GitHub. So, great job everyone! This is an important milestone.

(Next target: highlight.js, the syntax highlighting library used by Discord, among others!)

Create a Text Adventure in Mini Micro

JoeStrout — Thu, 10 Sep 2026 03:12:31 +0000

Text adventures (sometimes called interactive fiction) are a classic and celebrated game genre — see 50 Years of Text Games, for example. Mini Micro has not neglected this genre; among the built-in demos is a 5-minute text adventure called The Greedy Gargoyle, which you can play on the web right here.

If you have Mini Micro running on your own computer, you can also run this demo with run "/sys/demo/textAdventure".

But did you know that this demo is more than just a demo - it's a foundation you can import and use to make your own text adventures?

In this post, we'll walk through making a little custom adventure with three rooms to explore, and an object you can pick up and move around.

The import trick

Because textAdventure.ms is located in /sys/demo rather than /sys/lib, it's not on the standard import path. So we need to add /sys/demo/ to env.importPaths before we try to import it. Then, to make the various classes and methods in that module easier to use, we're going to copy the contents of the imported module into locals. So the top of the program will look like this:

if env.importPaths[0] != "/sys/demo" then
    env.importPaths.insert 0, "/sys/demo"
end if
import "textAdventure"
for id in textAdventure.indexes
    locals[id] = @textAdventure[id]
end for

In Mini Micro, reset the program state, then edit, and paste in the above code. Give it a run. You can then check to be sure it worked by entering Object at the prompt. Object is the base of the textAdventure class hierarchy; if it returns a map containing keys like "location", "contents", and "name", then it worked.

Required Globals

Next, there are a small number of globals values needed by the textAdventure code, which are not automatically defined when it's imported this way. So edit again and add this code:

// Globals required by the textAdventure code:
lamp = {}
lamp.lit = true
done = false
normalColor = color.aqua  // (or whatever you prefer)

(This will probably be improved in Mini Micro 2, but having this code won't do any harm in any case.)

...And Create!

Now the fun part: build your virtual world! A world in a text adventure consists of a bunch of objects, including rooms (locations), exits (doors/passageways connecting rooms), and things (items). You create these by simply instantiating various classes in textAdventure.ms, and configuring their properties.

For this tutorial, we're going to make a little world consisting of a small one-room house, with a front yard and an attic. So, let's start with the yard. Edit your program again and add this code:

// Now, let's define our universe!
yard = new Room
yard.name = "Front Yard"
yard.desc = "You're standing in the yard in front of a small house." + 
  "  The grass is long and overgrown with weeds that almost hide " +
  "an old car tire.  The house lies directly to the north."
Player.moveTo yard

Not too hard, right? We're creating a new Room, and giving it a name and description. And then, to make the player start in this room, we add a Player.moveTo yard call.

The Main Loop

Finally, to get our first playable demo, we need a main program. This clears the screen, does the initial look at the player's location, and then enters a simple main loop that takes input from the player and handles it.

// Main loop.
text.color = normalColor
clear
look
while not done
    text.color = color.gray
    cmd = input(">").lower
    text.color = normalColor
    handleCommand cmd
end while

Add the above code to your program, and then run it. It should be a playable but very minimal game. You can use the i or inventory command to check your inventory (which is empty), you can look again at the room you're in, and... well, that's about it so far.

Create some more!

Let's make the world bigger! The code below creates two more locations, house and attic, and then connects them all up with doors. Insert this code after Player.moveTo yard, but before // Main loop.

house = new Room
house.name = "Small House"
house.desc = "You're on the main floor of a small one-room house."

attic = new Room
attic.name = "Attic"
attic.desc = "You're in the attic of the small house.  It's dusty " +
  "and full of cobwebs.  Wan light comes from a tiny window at one " +
  "end.  The only exit is down."

doors = Exit.connect(yard, "north", house)
doors[0].altNames = ["house", "door", "n"]
doors[0].salient = false
doors[1].altNames = ["exit", "leave", "out", "door", "s"]
doors[1].salient = false

doors = Exit.connect(house, "up", attic)
doors[0].altNames = ["attic", "trapdoor", "n"]
doors[0].type = "trapdoor"
doors[0].fullName = "trapdoor in the ceiling"
doors[0].open = false
doors[1].altNames = ["exit", "leave", "out", "door", "d"]
doors[1].salient = false

In this particular example, the door configuration is longer than the locations themselves, but that's not always the case. Here's what's going on with the exits:

Each call to Exit.connect returns two exits; element [0] in the forward direction (e.g. yard to house), and element [1] in the reverse direction (e.g. house to yard).
Giving a generous supply of altNames allows the player more freedom in what they type to move around; instead of always go north, they can say go house, or door, or just n.
Setting salient = false keeps the door from being automatically listed among the room contents. Try commenting that line out and see how it behaves.
Setting type just gives the engine a more colorful term for the exit than "door"; similarly, setting fullName helps color the description that appears for a door that is salient.
Finally, doors default to already open; set open = false to make it closed.

Run the program at this point, and you should be able to navigate from the yard to the house, and then up into the attic, and back.

Add some things!

A game consisting only of empty rooms isn't a very interesting game! The core of any adventure is a set of things you can pick up, carry around, and interact with. Our description of the front yard claimed there was a tire in the weeds. This brings up an important design rule for any text adventure game:

If you mention an object in a description, players will try to grab it.

So, a well-written game has actual objects (possibly with salient = false) that correspond to any object mentioned in the descriptions.

In this case, we mentioned a tire, so we better make a tire. And to keep things simple, we'll take it out of the room description and let the game engine list it when present. So, start by editing the code that sets yard.desc to:

yard.desc = "You're standing in the yard in front of a small house." + 
  "  The house lies directly to the north."

And then, after creating the doors (or really anywhere after yard is built), add new code for the tire:

tire = new Thing
tire.name = "old tire"
tire.altNames = ["tire", "tyre"]
tire.desc = "It's just an old, worn-out car tire."
tire.moveTo yard
tire.descInRoom = function
    if self.location != yard then return super.descInRoom
    printWrap "The grass is long and overgrown with weeds that " +
      "almost hide an old car tire."
end function

This example is a little fancier than your typical room object, but I couldn't help myself; tweaking the behavior of objects to make them "special" is a large part of the magic of text adventure games. And the magic in this case is relatively minor: it's just overriding the descInRoom function, so that if it is located in the yard, it prints a special description about it being among the weeds.

There are other ways we could have handled this; perhaps better would be to make the tire nonsalient, and give yard a custom desc function that includes the bit about the tire when the tire is present, and a different message about weeds (but no tire) when it is not. This is left as an exercise for the reader.

Now run the game again. Try picking the tire up, carrying it around, dropping it in the house or the attic, or back in the yard, and be sure to look at your surroundings to verify it's all working.

Overriding the stock code

You might notice a minor bug that doesn't appear in my screen shot above -- there's an extra space every time the game says an old tire. It turns out this is a bug in textAdventure.ms that was never noticed because none of the items in the stock game begin with a vowel.

But good news! You have the power to replace any imported method. Add this code near the top of your program, after the required globals:

// Fix the minor bug in the Thing.a function
Thing.a = function
    if "aeiou".indexOf(self.name[0]) != null then return "an"
    return "a"
end function

This code is copied directly out of textAdventure.ms, but "an " has been replaced with "an" (without the extra space). Problem solved.

Here's the complete tutorial code if you need it.

// Demo text adventure.

if env.importPaths[0] != "/sys/demo" then
    env.importPaths.insert 0, "/sys/demo"
end if
import "textAdventure"
for id in textAdventure.indexes
    locals[id] = @textAdventure[id]
end for

// Globals required by the textAdventure code:
lamp = {}
lamp.lit = true
done = false
normalColor = color.aqua

// Fix the minor bug in the Thing.a function
Thing.a = function
    if "aeiou".indexOf(self.name[0]) != null then return "an"
    return "a"
end function

// Now, let's define our universe!
yard = new Room
yard.name = "Front Yard"
yard.desc = "You're standing in the yard in front of a small house." + 
  "  The house lies directly to the north."
Player.moveTo yard

house = new Room
house.name = "Small House"
house.desc = "You're on the main floor of a small one-room house."

attic = new Room
attic.name = "Attic"
attic.desc = "You're in the attic of the small house.  It's dusty " +
  "and full of cobwebs.  Wan light comes from a tiny window at one " +
  "end.  The only exit is down."

doors = Exit.connect(yard, "north", house)
doors[0].altNames = ["house", "door", "n"]
doors[0].salient = false
doors[1].altNames = ["exit", "leave", "out", "door", "s"]
doors[1].salient = false

doors = Exit.connect(house, "up", attic)
doors[0].altNames = ["attic", "trapdoor", "n"]
doors[0].type = "trapdoor"
doors[0].fullName = "trapdoor in the ceiling"
doors[0].open = false
doors[1].altNames = ["exit", "leave", "out", "door", "d"]
doors[1].salient = false

tire = new Thing
tire.name = "old tire"
tire.altNames = ["tire", "tyre"]
tire.desc = "It's just an old, worn-out car tire."
tire.moveTo yard
tire.descInRoom = function
    if self.location != yard then return super.descInRoom
    printWrap "The grass is long and overgrown with weeds that " +
      "almost hide an old car tire."
end function


// Main loop.
text.color = normalColor
clear
look
while not done
    text.color = color.gray
    cmd = input(">").lower
    text.color = normalColor
    handleCommand cmd
end while

Go forth and create!

You have now created a simple world with a house, an attic accessible via a trapdoor, and an overgrown front yard containing an old tire you can manipulate. That's a foundation for high adventure if I've ever heard one.

Where you go from here is up to you. Read textAdventure.ms (in Mini Micro or on GitHub) to learn the full set of object types, properties, and methods available to you. They include things like countable objects (like the coins in The Greedy Gargoyle) and liquid (like the water in the pool).

I'd recommend you start with the built-in functions and classes, and sketch out your world as much as you can with these. Then start building in special behaviors. This is how you make puzzles: objects that react based on where other objects are, or what state they're in, or special commands entered by the user.

Or, if you don't like puzzles, fill your world with mobs and craft a combat system. Add magic if you like. Or maybe you prefer ray guns and rocket ships. It's all possible.

Do you have any fond memories of text adventures you've played, or is the genre new to you? What new adventures would you love to see? Share your thoughts in the comments below!

Living Without Constructors

JoeStrout — Wed, 05 Aug 2026 21:52:33 +0000

The MiniScript language does not have constructors; when you create a new object with new, like

okBtn = new PushButton

...what you get back is exactly a map with __isa set, like:

{"__isa": PushButton}

So, hooray for simplicity! But boo for wanting to do any more sophisticated initialization when your object is created. In other languages, you'd likely do such initialization in a constructor (a method that automatically runs when you create an instance of a class). But MiniScript doesn't have those. So what do you do?

Option 1: Separate `init` method

The first and most obvious remedy is to have a separate init method that you call after creating each object. You can find an example of this in the Asteroids demo at /sys/demo/asteroids. Line 37 defines GameSprite as a subclass of Sprite (GameSprite = new Sprite), and then lines 55-59 give it an init method:

GameSprite.init = function
    self.v = {"x":0, "y":0}
    self.destroyed = false
    display(4).sprites.push self
end function

Then later, it makes a subclass of GameSprite called TimedSprite, to represent a game sprite that despawns after a little while:

TimedSprite = new GameSprite
TimedSprite.despawnTime = 0
TimedSprite.init = function(duration = 0.5)
    super.init
    self.despawnTime = time + duration
end function

(TimedSprite also has a custom update method, but that's not important here.) Note how TimedSprite.init calls super.init, ensuring that the base class gets a chance to do its usual initialization. Similarly, when we make a subclass of TimedSprite called Bullet, it does the same thing:

Bullet = new TimedSprite
Bullet.instances = []
Bullet.init = function(lifetime = 0.6)
    super.init lifetime
    Bullet.instances.push self
end function

Then when the player presses the fire button, we create a new bullet with the create, then initialize pattern (line 116-117):

        b = new Bullet
        b.init

You can find other examples of this pattern in some other demos, like fatbits and flappyBat. This pattern works. But it's no longer my favorite solution.

Option 2: Static factory method

The other basic option is to never have callers use new directly, but instead to call a factory method on the class. A factory method is nothing more or less than a method whose job it is to create and return an object. And a "static" method is one that you call on the class, rather than on some specific object. I've lately settled into the habit of naming static methods and properties with a capital first letter, to distinguish them from ordinary instance methods and properties, and most typically, I call my factory method Make.

So this solution is just: stick a Make method on your class that creates, initializes, and returns a new instance.

You can find examples of this pattern in /sys/demo/soundLab, which first makes a RectControl class, and then makes several subclasses of that, including PushButton:

PushButton = new RectControl
PushButton.Instances = []
PushButton.image = desktopPic.getImage(248,106, 20,20)
PushButton.icon = null

PushButton.Make = function(left, bottom, image=null, icon=null)
    noob = new self
    noob.left = left
    noob.bottom = bottom
    noob.icon = icon
    if image then noob.image = image
    noob.width = noob.image.width
    noob.height = noob.image.height
    PushButton.Instances.push noob
    return noob
end function

Be sure to notice the neat trick here: to actually create the new instance, this Make method says noob = new self. Here self is whatever class the Make method was called on; so if the user said PushButton.Make, then new self is equivalent to new PushButton. But if they call Make on some subclass of PushButton, then this new will instantiate that subclass instead.

Of course we're only using new here at all because the base class (RectControl) did not define a Make method. What if it does? Well, let's look at the WaveButton class, which derives from PushButton:

WaveButton = new PushButton

WaveButton.Make = function(left, bottom, imageIdx=1, iconIdx=0)
    return super.Make(left, bottom, WaveButton.Images[imageIdx], WaveButton.Icons[iconIdx])
end function

The WaveButton.Make method just calls super.Make to create the new instance. In this case, we only overrode Make in order to pass the appropriate button image and icon. But we could have also done something like:

WaveButton.Make = function(left, bottom, imageIdx=1, iconIdx=0)
    noob = super.Make(left, bottom, WaveButton.Images[imageIdx], WaveButton.Icons[iconIdx])
    // ...do other initialization with noob here...
    return noob
end function

Why Factory Methods Rock

A strong case can be made that factory methods are actually superior to constructors. Here are some reasons why:

You can have multiple factory methods on the same class, with unique names making it clear what each is for: MakeForStorage or MakeFromFile or whatever.
A factory method doesn't have to actually create a new object; it could pull an old object out of a recycling pool, or some sharable instance, and the caller doesn't need to know or care.
A factory method could return a different type based on the parameter values: maybe you need a different class for high-speed sprites (like bullets) vs stationary sprites (like trees). That logic can be hidden inside the factory method, so callers don't have to remember it.
A factory method can fail gracefully, returning null or (in MiniScript 2) and error in place of a new object. new can never do that.
Factories are easier to evolve. You can change the return type, caching policy, initialization steps, etc., without having to update all the callers.

Some of these benefits would also apply to the init method, but most of them would not.

Conclusion

New MiniScript programmers are sometimes surprised by the lack of a constructor feature. But now that you know how to live with it, it's not a lack at all! Just a different way of doing things.

What's your favorite approach to creating & initializing objects in MiniScript? Share your thoughts below!

The Mini Micro Desktop GUI

JoeStrout — Wed, 01 Jul 2026 23:26:19 +0000

https://miniscript.org/MiniMicro is a virtual home computer with a primarily command-line interface. It boots into a prompt with a friendly blinking cursor, where you can type MiniScript commands or code to navigate around the system and get things done.

But, among the demos in the /sys/demo directory is a program called desktop. You can run it from there like any other demo, or you can use the convenient desktop function, built right in as one of the globals defined in /sys/startup.ms. Just type:

desktop

and Mini Micro will load up the desktop GUI (graphical user interface)!

The initial state has one window open, showing the mounted disks -- in my case that is /sys, /usr, and /usr2. You can drag the window around by any part of the gray border, except the textured lower-right corner, which stretches the window out. You can double-click folders to open them in new windows:

Power-user Tip

If you hold the Alt/Option key while double-clicking a folder, it will simultaneously open that folder and close the previous window. This is known as "Tunneling".

Scrollbars appear on disk/folder windows, which can be used to scroll around the files therein. You can double-click some files (for examples, pictures and text files) to preview them with the view command, or double-click MiniScript files to run them. The desktop acts as a shell, so when the program exits normally, the desktop should reappear. If the program aborts due to an error, or you press Control-C, then you can type exit to return to the desktop (or just use the desktop command again).

The File menu has three commands, all functional: New Window, Close Window, and Exit to Shell (which really means, exit to the standard command-line prompt). Close Window closes the frontmost window; you can also do that from the keyboard by pressing the W key.

The Window menu also works, and provides quick access to any of the windows you have open.

And that's about it. /sys/demo/desktop is more of a demo than a fully functional GUI. But maybe, in Mini Micro 2.0, it could be.

A fully functional desktop?

I have big plans for Mini Micro 2.0... probably too big, if I'm being honest. But among them is the idea of turning this demo into a proper, full-fledged desktop environment you can actually use to browse and manage your files. GitHub issue #61 is all about this possibility, which would include ways to move/rename files, desk accessories you could add to or replace yourself, etc.

But what do you think? Is this worth spending time on, or would you rather use the command line anyway? And if you do want to spend significant time in the desktop environment, what features are most important to you?

Let us know in the comments below, or chime in on GitHub. I can't wait to hear your thoughts!

MiniScript Weekly News — June 25, 2026

JoeStrout — Thu, 25 Jun 2026 20:50:45 +0000

Development Updates

MiniScript 2 kept moving fast this week, with Preview 5 now available: https://github.com/JoeStrout/miniscript2/releases/tag/v2.0-preview-5. Joe has been polishing error handling, tightening up stack traces, and adding a key module for console input along the way. If you’ve been testing the previews, now’s a great time to keep poking at edge cases and reporting what you find.

A big performance highlight landed with computed lists, which make things like range(...) and list repetition much faster without changing how they behave in normal code. Joe also wrote up the idea in a new Dev.to post: Computed Lists in MiniScript 2.

The key module has landed for console apps too, with .available and .get mimicking their behavior in Mini Micro. That should open the door for more interactive command-line MiniScript tools and games.

Community Projects

Congratulations to Venti for shipping a tutorial update to their game, Observe. It now teaches MiniScript in-game, which is a fantastic way to bring new players into the community while showing off what can be built with the language.

maho_citrus shared Regicide.ms-unofficial, a MiniScript take on the card game Regicide. Joe immediately recognized it as a neat find and even suggested a Mini Micro GUI version—great encouragement all around.

Show and Tell

In #mini-micro, Trey Tomes showed off progress on his SVG renderer, which now handles the <animate> tag: demo/constellation2.svg. It’s a lovely example of experimentation leading to something genuinely useful and expressive.

Meanwhile shellrider has been pushing on 3D rendering experiments, adding a z-buffer and intersecting triangles. Joe chimed in with encouragement and a bit of nostalgia about older software renderers, which feels very on-brand for this community.

Discussion Highlights

There was a lively thread around the new MiniScript 2 previews, including testing on Windows and Linux, stack traces, ANSI terminal behavior, and consistency across builds. Community testing quickly found and helped fix a few early crashes, which is exactly the kind of collaboration that makes preview releases so valuable.

Joe also shared that MiniScript 2 is coming along well for embedding, but he’s recommending a little patience before others start integrating it heavily. In the meantime, he’s working toward a smoother path for raylib-miniscript and other targets, including better build support and more portable tooling.

Thanks for reading, and thanks to everyone sharing code, tests, ideas, and projects. See you next week!

Upcoming Game Jams

These upcoming jams look like a great fit for Mini Micro:

The 52 Card Pickup Jam #1 (starts 2026-06-29 11:00:00) — A perfect excuse to build a stylish card game or clever twist on classic decks, with plenty of room for polished visuals, sound, and inventive mechanics.
KILL YOUR DARLINGS Mini Jam No. 1 (starts 2026-06-26 05:01:00) — A perfect anti-scope-creep jam that celebrates tiny, finished, weirdly personal projects over polish—ideal for making something bold, simple, and delightfully unexpected in just three days.
One Game A Week Jam #8 (starts 2026-06-29 16:00:00) — A fast, small-scope jam built around clever puzzle design and unusual weekly prompts, perfect for making a polished retro-style brainteaser with a striking mirror-and-path twist.
Mini Jame Gam #56 (starts 2026-06-26 11:00:00) — A beginner-friendly jam with a flexible theme, a required special object, and a short prototype-friendly format makes this a great place to build something creative, polished, and fun.
Fake Update Jam (starts 2026-06-29 11:00:00) — A delightfully meta jam where the game itself can pretend to boot, patch, glitch, and rewrite its own rules—perfect for inventive UI tricks, fake system screens, and story-driven surprises.

Computed Lists in MiniScript 2

JoeStrout — Wed, 24 Jun 2026 22:39:19 +0000

Progress on MiniScript 2 has been rapid lately, and it's now in the "final polish" stage. Today that included adding a cool new feature, an optimization that many users will never consciously notice, but which will be quietly improving things in almost every MiniScript program. This feature is computed lists.

Computed What, Now?

Here's the issue we set out to solve: a for loop in MiniScript must iterate over a list, string, or map; and very often, that's a list that comes from the range function. Here's a typical example:

sum = 0
for i in range(1000000)
  sum += i
end for

That range function, until today, would allocate a million-and-one-element list and store the numbers from 1 million down to zero in it, just so we can assign each number to i in turn. And then it would release that list, to be garbage collected at some point. This is a lot of extra work that we really didn't need to do. Instead of storing all those numbers, we could instead just store the information we need to compute any element on demand. This saves a ton of allocation and deallocation, and in many cases (like when you bail out of your loop early) it saves computation too.

Python faced the same problem, and chose (starting with Python 3.0) to make range return an iterable rather than a list. That's fine for cases like the above, but in cases where you actually needed a list, you have to cast it through the list() function to get one. This is a gotcha that everybody trips over initially, and just extra noise in the code even once you're used to it.

Our Solution: Computed List

For MiniScript 2, we have chosen a different solution: a list may, under the hood, be a computed list. Rather than storing individual values, a computed list stores just three: the base, the step, and the count. But unlike Python, this is completely transparent to your code; it is still a real list, and may be used exactly like any other list.

So now when you run the code above in MiniScript 2, it no longer allocates and precomputes over a million elements. Instead it allocates space for just 3 elements. But it acts like it has a million and one elements, in every way (unless you use the info intrinsic to peek at its computed flag).

You get such a computed list, currently, in two ways:

The range function always returns a computed list.
List replication, i.e. [x] * n, returns a computed list if x is any immutable value and n is an integer.

What Stays Computed

There are lots of things you can do with a computed list that leave the list in computed form, and just calculate the answer (very quickly). If foo is such a list, then all of these work directly on the computed data:

foo.len
foo[i] for any index i
foo[i:j] slicing from i up to j
foo.pop (yes, it mutates the computed list!)
foo.sum and other non-mutating intrinsics
freeze foo (making it into a frozen computed list)

That loop above could have been written as simply range(1000000).sum, and it very quickly computes the right answer, without ever allocating a million-element list.

When It Can't Stay Computed

However, unless you freeze the list, it's still a mutable object and you can change its contents. This generally requires "materializing" the list, i.e., at this point MiniScript goes ahead and allocates as much space as needed to hold all the values. (The exception to this rule is pop, which keeps it computed and merely reduces the count.) So, any of these operations will materialize the list:

foo.push x
foo.remove i
foo.insert i, x
foo[i] = x
foo.sort

At this point you lose the benefit of having a computed list, but that's OK. You're no worse off than we were yesterday, when we didn't have computed lists at all. And critically, you don't have to think about this. You ask for a list, you get a list, MiniScript keeps it computed when it can and materializes it when it must. Everything just works.

Performance

We built some benchmarks to measure code that relies heavily on big lists without mutating them, as well as code that does need to mutate them (and so can't take advantage of computed lists). This new feature brought about a 100X speedup in the first case, and had no measurable impact on the second.

Of course the improvement will depend greatly on the details of what the code is doing, but the key point is, as expected, this is an overall win. Not only do we avoid allocating and deallocating big hunks of RAM, but also a computed list (which is only 3 elements) fits comfortably into all levels of the memory cache hierarchy, unlike bigger lists. Cache misses are a major bottleneck in a lot of compute-heavy code, so this optimization wins both ways.

Life is Good

I'm proud of this solution because it gives us enormous benefits in cases that were needlessly slow before, but doesn't require the user to learn or remember anything new. I mean, I just told you all about it, but that was for sheer "Gee Whiz"-ism — nobody needs to understand what you now know!

And it does all this in a way that is relatively simple and didn't require a ton of new code under the hood, either.

This new feature will ship with MiniScript 2 Preview 6 (probably tomorrow). If you use command-line MiniScript, or would like to, keep your eye on the releases page, and give it a try!

Announcing MiniScript 2 Preview Builds!

JoeStrout — Thu, 18 Jun 2026 00:03:03 +0000

As announced in our MiniScript Road Map for 2026, the big push this year is working on MiniScript version 2.0. This first major update to the MiniScript language will be substantially faster than MiniScript 1.x, and include some important new language features too.

I'm pleased to say it's going very well -- we have MiniScript 2 written in both C# and C++ now (in a more clever way than before), and it's right on schedule, or even ahead.

If you are impatient and want to download MiniScript 2 immediately, please do! You can find the latest releases here.

Improved REPL

The first thing you'll notice when you run MiniScript 2 interactively (i.e., without giving it a script to run) is a much fancier user experience in the REPL (read-eval-print loop).

There are two main differences from the 1.x REPL:

Every input goes onto an _in list (as a string); every result goes onto an _out list (as whatever data type the result was). You can refer to these in your code, which is often quite convenient when you want to build on a previous result, write the whole input history out to a file, etc.
Terminal control codes are used to display less-relevant text (like the initial version info and input/output labels) in subdued text, your inputs as ordinary text, and outputs as bold text. This helps you focus on the most important info (and is also quite pretty!).

New `error` Data Type

Error handling in MiniScript 1.x was rather weak; mostly it involved functions returning something unexpected when things went wrong, like null or a string error message instead of the usual result map.

After a lot of community discussion (and yes, we did consider exceptions and try/catch), we settled on an approach to error handling that I think is very elegant. There is a new error data type, equal in status to number, string, list, map, etc. Error values have some special behaviors: trying to use an error value in almost any way will terminate your program, but you can inspect it to see what the error is, where in the code it occurred, etc.

Read more about this (and other features) in the Language Changes doc.

Frozen Maps & Lists

Another language enhancement in 2.0 is frozen lists and maps. Lists and maps are normally "mutable," which means they can be changed in place; if you have two references to the same list, and you change the list via one of them, you see the change in the other.

 _in[17]: a = [1,2,3]

 _in[18]: b = a

 _in[19]: a[0] = 999

 _in[20]: b
_out[20]: [999, 2, 3]

This is often exactly what you want. But sometimes you want to build a list or map that can't be changed; i.e. is "immutable". In Python, they have a whole other data type for an immutable list (the "tuple"), with different syntax, just for this purpose.

In MiniScript 2, you can instead freeze a list or map. A frozen list or map is immutable and can't be changed. Some intrinsic APIs return frozen maps now, like version for example.

 _in[21]: version 
_out[21]: {"miniscript": "2.0", "buildDate": "2026-06-17", "platform": 
"macOS 13.6.4", "host": "2.0 Preview", "hostName": "Command-Line (Unix)", 
"hostInfo": "https://miniscript.org/cmdline/"}

 _in[22]: version.host = "2.1"
Runtime Error: Attempt to modify a frozen map

MiniScript will also use a frozen copy of a list or map when you use it as a map key, since mutating a map key is very bad juju.

This is one of those refinements that new users probably won't even notice, but for serious MiniScript users, it will save a lot of headaches.

Function Notes & `info`

Another nifty new feature of MiniScript two is function notes. If the first statement in a function evaluates to a constant string, then this string is stored on the function, and can be accessed via the new info intrinsic, like so:

 _in[4]: f = function(x,y)
    ...:   "Return the magnitude of vector x,y"
    ...:   return sqrt(x^2 + y^2)
    ...:   end function

 _in[7]: info(@f)
_out[7]: {"type": "funcRef", "name": "f", "note": "Return the magnitude 
of vector x,y", "params": [{"name": "x", "default": null}, {"name": "y", 
"default": null}], "closure": 1}

 _in[10]: info(@f).note
_out[10]: Return the magnitude of vector x,y

This provides a standard, convenient place to give a little hint or reminder to users about what the function does. (Note to self: I'll need to go through all the /sys disk modules and add function notes!)

Improved Performance

I already discussed performance in our March update, so I won't repeat that here. Suffice to say, MiniScript 2.0 is many times faster than 1.x, comparable to Python, and we still have plenty of opportunities for pushing it further.

Right On Track

The schedule from December laid out these milestones:

Date	Milestone
2026 Q1	MS2 compiles & runs a subset of MiniScript
2026 Q2	MS2 feature complete (whole language implemented)
2026 Q3	MS2 testing, refinement, & polish
2026 Q4	MS2 released 🥳

We're at the end of Q2 now, and the first two steps above are done. A lot of stuff in the "testing, refinement, & polish" category has already been done too (for example, the terminal colors/styles and in/out value lists in the REPL). So we're actually a little ahead of schedule. It's time now for some serious testing -- but we're also going to start in on Raylib bindings within the next month, which wasn't expected until Q2.

Please Help!

Did I mention that it's now time for some serious testing? That means you! I will do what I can, but I can't do it all by myself.

(Indeed, we wouldn't be where we are today without some very helpful testing of Windows and Linux builds by Discord users BibleClinger, minerobber, shellrider, and MoTrix -- thanks guys!)

So please download the preview release for your platform, and take it for a spin. Throw some of your older scripts at it. Write some new scripts. Explore the new language features. Try to break it! This is a large amount of brand new code, much of it quite complex, so there are almost certainly bugs to be found.

When you find a problem, either bring it up on Discord (in the #miniscript-2 channel), or file an issue on GitHub. Do the same if you have some suggestion or feature request -- we're mostly feature-frozen at this point, but it's not too late for small refinements, especially if they bring important quality-of-life improvements.

I hope you're excited as I am for this major milestone. MiniScript 2 unlocks all the other cool stuff in the Road Map. Let's go!!

MiniScript Weekly News — June 05, 2026

JoeStrout — Fri, 05 Jun 2026 18:12:46 +0000

Development Updates

MiniScript 2 kept moving forward this week with a solid round of cleanup and polish. The dev log mentions Unicode improvements, faster string handling, O(1) intrinsic lookup, a !help metacommand for the REPL, and a few opcode / naming cleanups to make the internals more consistent.

Dev log: JoeStrout/miniscript2

There was also useful progress on cross-platform builds. After some back-and-forth with compiler quirks, the project is now building on more than one platform, and Joe is weighing the best Windows strategy going forward: MSVC, MinGW-w64, or potentially clang-cl.

The Mini Micro sysdisk also got a nice little refactor. The LCARS demo now has its app modules split into /sys/lcarsApps, and the new structure can also load modules from /usr/lcarsApps, opening the door for community-made add-ons.

Commit: Extract LCARS app modules into sys/lcarsApps

Community Projects

Trey Tomes has been building a Mini Micro SVG experiment, and it’s looking really fun. He shared parser and renderer work for circles, colors, and XML handling, along with a constellation-style SVG demo — a great example of diving into a new graphics idea in MiniScript.

Parser: parseSvgColor.ms
XML helper: xml.ms
Renderer: render.ms

We also saw a new MiniScript-powered game called Touhou Creator on Steam, which is exciting news for the ecosystem. Huge congrats to hachimi for sharing it — always wonderful to see MiniScript reaching a broader audience.

Steam link: Store page

Community & Discussion Highlights

A few newcomers stopped by looking for tutorials and next steps, and the community had some good recommendations ready. Joe pointed people toward the Mini Micro getting-started guide, the intro-to-programming resource, and the language try-it page, while also reminding everyone that MiniScript is best learned by doing.

There was also some useful discussion around tooling and distribution. People talked about a potential Lutris runner for Mini Micro on Linux, and Joe clarified that a Mini Micro mobile version is still on the roadmap, just not ready yet.

Roadmap update: MiniScript roadmap update — March 2026

Events & Outreach

A new Micro Jam was announced with an ANIMALS theme, which sounds like a great excuse to explore Mini Micro’s built-in sprite resources. If you’ve been waiting for a gentle prompt to make something small and playful, this is a lovely one.

Jam: Micro Jam #059 — ANIMALS

On the outreach side, Dat_One_Dev reported encouraging movement on getting Mini Micro covered by GameFromScratch. It’s always great to see community members helping spread the word beyond our usual circles.

Channel: GameFromScratch on YouTube

That’s it for this week — thanks to everyone building, testing, sharing, and welcoming new folks. See you next week!

Upcoming Game Jams

These upcoming jams look like a great fit for Mini Micro:

Slop Jam 2: Electric Boogaloo (starts 2026-06-12 22:00:00) — An anything-goes, low-pressure jam with no engine restrictions and a theme revealed at the start, making it a great place to whip up a quirky 2D, pixel, or text-based game over a weekend.
The Demo Jam (starts 2026-06-07 23:00:00) — A strong fit for a retro-style, bite-sized vertical slice with lots of room for polished presentation, teaser content, and playful demo-only limitations like locked features or a mock ‘full version’ hook.
Turtley in Love - Pride 2026 (starts 2026-06-12 20:00:00) — A one-week Pride-themed jam with a cozy, celebratory vibe and an open theme makes this a great chance to create something heartfelt, playful, and approachable.
District Jam VII (starts 2026-06-12 23:00:00) — A relaxed, short-form jam with any engine allowed and no technical constraints, making it an excellent chance to build a pixel-art, tile-based, or text-driven game in a friendly community setting.
Tiny Game, Big Twist Jam (starts 2026-06-08 11:00:00) — A 3-day jam built around small, surprising games with a meaningful twist, leaving lots of room for clever mechanics, experimental storytelling, and memorable genre shifts.

MiniScript Weekly News — May 27, 2026

JoeStrout — Thu, 28 May 2026 02:05:15 +0000

Development Updates

The MiniScript 2 work continues to move forward at a brisk pace. Joe’s latest dev log shows major progress on shell intrinsics like file and import, plus support for RawData and GCHandle, while also tightening up compiler behavior around globals, super, short-circuiting, and error handling. The recent commit trail is especially busy, with fixes for function storage, variable naming in conditionals, and a cleanup to remove extern "C" from CS_value_util.h for better compiler compatibility.

There’s also been a healthy round of real-world testing against existing demos and code. In particular, superstartrek has been a great stress test for edge cases, helping uncover and resolve a cluster of bugs that made the system stronger overall.

Community Projects

A quick update from Redspark on Emberfall: the engine has nearly been converted to Raylib-MiniScript, and work is underway on the 3D renderer. That’s the kind of behind-the-scenes momentum that makes a future show-and-tell post especially exciting.

A big shout-out to everyone helping push MiniScript 2 across different platforms. MoTrix and minerobber have both been digging into build issues, with fixes and PRs emerging for Linux, Ubuntu, and Windows/MSVC compatibility — a fantastic example of community-powered portability work.

Discussion Highlights

The community had a lively discussion about decorators and argument unpacking in MiniScript. Joe floated the idea of a “decorators in MiniScript” article, and the conversation turned into a practical look at wrappers, apply-style functions, and how argument packing/unpacking might work without too much syntactic sugar.

Mini Micro users also weighed in on documentation ideas, with suggestions ranging from a “Getting Started” guide to a whimsical 1980s-style manual for the virtual computer. Separately, Joe is exploring hardware possibilities for a future “hardware Mini Micro” setup, including Intel N100 mini-PCs and Orange Pi options.

Community Notes

Welcome to all the new folks joining the server this week! It’s always nice to see more people arriving with game-dev ideas, curiosity about MiniScript, and interest in helping shape what comes next.

There were also some fun project ideas in the mix, including a sci-fi cloaked-ship combat game and even a tongue-in-cheek dystopian tale about the “Spacers” versus the “Tabbers.” That kind of playful creativity is exactly what makes the MiniScript community so enjoyable.

Around the Community

Joe also shared a fun new mini-project on DEV: Where in the World Am I?. It shows how to use web services and simple 3D rendering to pinpoint your location on a rotating globe.

And on the Mini Micro side, Joe’s been thinking about future documentation and accessibility features, including possible TTS/STT support for Mini Micro 2. A promising model was shared here: Supertonic, with voice samples at supertone-inc.github.io/supertonic-py/voices.

Thanks for reading — happy scripting, and keep sharing what you’re building!

Upcoming Game Jams

These upcoming jams look like a great fit for Mini Micro:

YOU CAN PLAY THIS GAME JAM (starts 2026-05-30 04:00:00) — A highly accessible, beginner-friendly jam centered on pitching great ideas and designing for inclusivity, with no requirement to build a full playable prototype.
smilejam (starts 2026-05-17 23:00:00) — A perfect match for quick, intimate, experimental games: short playable pieces, strong mood, prose, collage, and low-pressure creativity all line up beautifully.
Cute Girls Doing Cool Things VN Jam 2026 (starts 2026-06-01 04:00:00) — A strong fit for a story-first project: the jam’s visual novel focus, cute-character premise, and summer-blockbuster energy all lend themselves to expressive 2D scenes, branching dialogue, and stylish presentation.
Never Joined A Game Jam Game Jam (starts 2026-05-29 14:00:00) — A beginner-friendly, no-theme jam focused on learning by doing, with plenty of room for a straightforward top-down shooter, simple UI, scoring, and extra polish like particles or enemy variants.
Trijam #374: The 3 hour game jam (starts 2026-05-28 21:00:00) — A fast, friendly jam built around making something fun in just 3 hours, with flexible rules, room for pre-made assets, and an emphasis on simple, playable ideas that are perfect for quick 2D projects.
Romance Game Jam #01 (starts 2026-06-01 06:00:00) — A very welcoming romance-focused jam with a four-week window, no voting pressure, and plenty of room for anything from sweet SFW stories to weird, esoteric love games.

Where in the World Am I?

JoeStrout — Wed, 20 May 2026 23:09:33 +0000

There are so many fun things you can do with web services, and most of them are trivial to use in Mini Micro. Today, let's use a couple of these together to plot your location on a map of the world!

Finding Your Place In the World

...begins by finding your external (or public) IP address. This is the Internet Protocol address by which you are seen on the internet, outside your local network. It's probably different from your internal (or private) IP address, which is what probably appears when you look at the network settings on your computer. We don't care how your computer is known to other computers in your house or neighborhood; we only care how packets are routed to it from the great wide world beyond. Fire up Mini Micro (available free here, and type:

http.get("https://api.ipify.org")

This should return an IP address, something like 66.212.203.27.

Now, to get information about that IP address, including the city it's in and an approximate latitude/longitude, we'll use a different web service:

http.get("http://ip-api.com/json/66.212.203.27")

You can replace the IP address above with whatever you got from the first query. The result will be a string of JSON code that contains your city, region, country, latitude, and longitude, along with the name of your internet service provider (ISP) and other details.

Putting this all together into a little program. Use edit to enter the code editor, then paste in the following:

import "json"
import "stringUtil"
clear

// What's my external IP address?
myIP = http.get("https://api.ipify.org")

// And where am I?
locJson = http.get("http://ip-api.com/json/" + myIP)
locInfo = json.parse(locJson)

pprint locInfo
print "You are in {city}, {region} ({country})".fill(locInfo)

Run this, and it should tell you where you are (along with all those other details). Neat, right?

Don't Tell Me, Show Me!

But we can make it more fun. Let's pinpoint you on a map of the Earth! edit your program again, delete the last two lines (pprint and print), and add in this additional code:

mapImage = file.loadImage("/sys/pics/earth_day.jpg")

// Find the pixel coordinates of our lat/long in this image
px = (locInfo.lon + 180) / 360 * mapImage.width
py = mapImage.height - (90 - locInfo.lat) / 180 * mapImage.height

// Draw a marker (using an offscreen PixelDisplay)
g = new PixelDisplay
g.clear color.black, mapImage.width, mapImage.height
g.drawImage mapImage
g.line 0, py, g.width, py, "#00FFFF88", 3
g.line px, 0, px, g.height, "#00FFFF88", 3
g.fillEllipse px-10, py-10, 20, 20, "#00FFFFFF"
g.drawEllipse px-15, py-15, 30, 30, "#00FFFFAA"
g.drawEllipse px-20, py-20, 40, 40, "#00FFFF88"
markedMap = g.getImage(0, 0, g.width, g.height)

// And draw the mapImage, fit to the screen!
scale = 960/mapImage.width
gfx.drawImage markedMap,
  480 - mapImage.width*scale/2, 320 - mapImage.height*scale/2,
  mapImage.width*scale, mapImage.height*scale

s = "{city}, {region}, ({countryCode})".fill(locInfo)
text.row = 2
text.column = 34 - s.len/2
print s

The result, if you happen to be my neighbor right now, should look like this:

The trick here is knowing that the map image uses a standard equiprectangular projection, where longitude and latitude both map linearly to x and y. That lets us convert from lat/long to pixel coordinates with some reasonably simple math. Most of the code above is then drawing the pinpoint lines and circles on top of the map.

(Note: if you are reading this in the future and live somewhere other than Earth, this code will need adjustment.)

Now in Animated 3D!

Let's take it one step further: combine what you've done so far with the globe demo! Follow these steps:

Save your program, if you haven't already.
edit "/sys/demo/globe" to load the globe demo code.
Select All (^A) and then Copy (^C).
Exit the editor, then edit your program.
Scroll to the bottom, and Paste (^V).
Find the line (at the top of the pasted code) that says bigMapImg = file.loadImage("/sys/pics/earth_day.jpg"), and change it to just say bigMapImg = markedMap instead.

That's it. Now run your program, and you should see your location on a beautiful rotating globe.

Never Be Lost Again

The http module is an often-overlooked gem in the Mini Micro APIs. With one little call we can get our external IP address, and with a second little call, get all sorts of information about that, including the info we need to place ourselves on a map. We also looked at how you are able — nay, encouraged! — to steal from the demo code and make it your own.

What do you think of this? Let me know in the comments below!

DEV Community: JoeStrout

MiniScript Weekly(ish) News — September 17, 2026

Development Updates

Community Projects

Discussion Highlights

Links Worth Checking Out

Upcoming Game Jams

Mini Micro "10 Most Wanted" Games

Wizardry/Bard's Tale-Style RPG

Space Combat Game

Pinball Construction Set

Lode Runner-ish Puzzle Platformer

Deep Text Adventure/Interactive Fiction

M.U.L.E.-like Economic Multiplayer Game

Archon-like Strategy/Action Game

Deckbuilding Roguelike Game

Musical Toy

Rube Goldberg Game

Developers Wanted!

MiniScript is a recognized language on GitHub!

Create a Text Adventure in Mini Micro

The import trick

Required Globals

...And Create!

The Main Loop

Create some more!

Add some things!

Overriding the stock code

Go forth and create!

Living Without Constructors

Option 1: Separate init method

Option 2: Static factory method

Why Factory Methods Rock

Conclusion

The Mini Micro Desktop GUI

A fully functional desktop?

MiniScript Weekly News — June 25, 2026

Development Updates

Community Projects

Show and Tell

Discussion Highlights

Upcoming Game Jams

Computed Lists in MiniScript 2

Computed What, Now?

Our Solution: Computed List

What Stays Computed

When It Can't Stay Computed

Performance

Life is Good

Announcing MiniScript 2 Preview Builds!

Improved REPL

New error Data Type

Frozen Maps & Lists

Function Notes & info

Improved Performance

Right On Track

Please Help!

MiniScript Weekly News — June 05, 2026

Development Updates

Community Projects

Community & Discussion Highlights

Events & Outreach

Upcoming Game Jams

MiniScript Weekly News — May 27, 2026

Development Updates

Community Projects

Discussion Highlights

Community Notes

Around the Community

Upcoming Game Jams

Where in the World Am I?

Finding Your Place In the World

Don't Tell Me, Show Me!

Now in Animated 3D!

Never Be Lost Again

Option 1: Separate `init` method

New `error` Data Type

Function Notes & `info`