Hey All!

PICO-8 0.2.5 is now up on lexaloffle, Humble, itch.io, and for PocketCHIP and web (Education Edition).

Edit: 0.2.5b is now up for Linux users who had trouble connecting to the BBS: https://www.lexaloffle.com/bbs/?pid=116441#p

Built-in Help

PICO-8 0.2.5 has built-in documentation on API functions and other topics. Type "HELP" at the prompt to see a list of topics in blue, and then e.g. "HELP GFX" to get more information about that thing.

While in the code editor, you can also press CTRL-U to get help on whatever is under the cursor, including operators and Lua keywords.

> HELP FILLP

String Indexing

Single characters can now be grabbed from strings using a familiar str[i] style syntax that means something similar to sub(str, i, i). The index is rounded down to the closest integer, and can be negative to index from the end of the string.

S="ABCDE"
S[2.6]  -- "B"
S[-2]   -- "D"
S[99]   -- ""

Strings in Lua are immutable, so this can only be used in an expression (on the right hand side of an assignment). e.g. s[2] = "z" is not allowed.

rnd(str) is now also accepted and returns a random character from string str.
// update: this might not be true from 0.2.5c: https://www.lexaloffle.com/bbs/?pid=116415#p

I've reverted sub() to pre-0.2.4 behaviour, which means that sub("abcde",2,_) returns "bcde". 0.2.4 was returning single characters when the 3rd parameter is non-numeric, which is now much better handled by str[i] style indexing. (Apologies if you were already using this behaviour!)

Editor Features

gfx_grid_lines in config.txt now takes a colour if you'd like super-visible grid lines in the sprite editor:

Map selections are now on a separate floating layer:

Pressing cursor keys in the map when nothing is selected now moves the camera, as I noticed some new users struggling to find/understand the pan tool and instead instinctively reaching for the cursor keys.

PICO1K Tools

Some changes intended to be useful for PICO1K Jam starting in September:

• ctrl-click on the compressed code capacity to get a realtime compressed size counter in bytes. This is the same size given with the INFO command, and when storing the cartridge as a tiny (code-only) binary rom with "EXPORT -T FOO.P8.ROM"

• "EXPORT -T @CLIP" can be used to get a hexdump of that same data written to clipboard. This is not very useful -- just a way to visualise exactly how much data is stored.

• SAVE @URL saves 3 characters when there is no sprite data included by omitting the redundant "&g=".

Web-Exportable Audio

extcmd("audio_rec"), extcmd("audio_end") can be used in web exports. The output file shows up as a downloadable .wav file. I'm hoping this will open the door for some cute sound generation tools.

Variable Width P8SCII Fonts

PICO-8 0.2.5 custom fonts can now specify how wide each character is when printed. This previously handled by doing things like injecting extra P8SCII commands into the output string, but this was cumbersome and meant that such fonts could not be shared as plain data. There were already pixel-wise cursor positioning commands in P8SCII, so I felt it makes sense to make this simpler. Also, I needed it for Picotron 8)

To specify a 3-bit width adjustment and 1-bit y offset for character 16..255, the data at 0x5608..0x567f is used. These would otherwise be the bitmap data for characters 1..15 which are all control characters and thus never printed.

Each 4-bit nibble in 0x5608..0x567f (low nibbles first) encodes the adjustments for one character:

bits 0x7: adjust character width by 0,1,2,3,-4,-3,-2,-1
bit  0x8: when set, draw the character one pixel higher (useful for latin accents)

An addition bit must be set at 0x5605 to enable size adjustments: poke(0x5605, 1). Otherwise the data at 0x5608..0x567f is ignored.

To test this out, try loading the font snippet generation tool:

> LOAD #FONT_SNIPPET

And then paste the following after the comment starting with "font attributes"

POKE(0x5605,1) -- turn on adjustments
POKE(0x5634,0x70) -- set nibble for i to 0x7

You can now observe that the big "i" in "quick" near the top of the screen only has 1px of space to the right instead of 2px.

Here's a helper function for setting the 4-bit nibble (val) for a given character (c):

FUNCTION ADJUST_CHAR(C, VAL)
  LOCAL ADDR = 0X5600 + ORD(C)\2
  LOCAL SHFT = (ORD(C) & 1) * 4
  LOCAL MASK = 0XF << SHFT
  POKE(ADDR, (PEEK(ADDR) & ~MASK) | (VAL << SHFT))
END

File Listings (for Dev Tool Carts)

Locally running programs can now use ls(path) to get a listing of any local directory. Entries that end with a "/" are directories. Use stat(124) to get the current path.

PATH = STAT(124) -- E.G. /FOO/
FILES = LS(PATH)
FOR F IN ALL(FILES) DO
  COLOR(F[-1] == "/" AND 14 OR 6)
  PRINT(F)
END

BBS cartridges are not able to access local file listings -- this is intended for developing tools to use locally. For example: a utility that makes it easier to browser cartridge data and copy between cartridges using reload() / cstore() which are able to read and write any local cartridge file using the 4th parameter.

Keyboard Scancode Remapper

If you're having trouble getting PICO-8 to detect some keys (especially numeric keypad keys / unusual laptop layouts), there is now a built-in tool for mapping those keypresses to something SDL2 understand. Run PICO-8 from commandline with -scancodes:

pico8 -scancodes

Or use some other tool to find out which scancodes the keys in question are producing, and then map them to something else in config.txt (look for map_scancodes)

Dynamic Libcurl Support (Linux)

The 32-bit and 64-bit linux builds now try to dynamically load libcurl by default in order to make bbs requests (e.g. download carts from splore). This will hopefully make installing on some platforms easier, including Steam Decks. When libcurl.so is not available, it drops down to the old wget behaviour (requires wget to be installed). If this works well, I'll also see about moving to the same scheme for raspi and mac builds.

More Doodlemud

Doodlemud is a toy multiplayer game designed to test the backend services that PICO-8's high score table (and future projects) will be based on. Try it here: https://www.doodlemud.com/#skatepark

This version is running on a completely new backend, custom written from scratch as a self-contained program using libwebsockets. My first attempt was built out of opensource components (nchan, redis, openresty, nginx), but because of PICO-8's unusual requirements, this was making customisation, debugging and devops more complex that it needed to be. Sometimes just reinventing the wheel with a bespoke C program is still the right approach even in the world of web services. There are currently 5 nodes running which are selected based on the user's location when making a new room:

Next Steps

It looks like PICO-8's 0.2.5 API is unlikely to change now (really, this time!), and the next task is to port the new additions to Voxatron for Voxatron 0.3.7. After that I'll continue working on the BBS functionality needed to log in from PICO-8 and submit high scores. If you're curious, you can see the current plan for the SCORESUB() function by typing HELP SCORESUB.

That's all for now -- I hope you enjoy the update and as usual let me know here or in bugs/ if you find anything spooky going on.

Full Changelog:

aajibi (512b intro) by zep [Click to Play]

Turn on your subwoofer!

This is a 512 byte intro I made for inercia 2022, a demoparty that took place in Lisbon over the weekend. It's the first time that I put the no longer secret 0x808 audio channel to use, with around 200 bytes of the (compressed) code spent on generating the music.

I was pleased to find that techniques used for golfing down visual effects' code size transfer quite well to audio. There are a lot of expressions in there that change meaning over time in a way that produces some kind of structured progression -- some planned, some not so planned. The whole thing is really a single effect, with a lot of janky math to roll out different audio and gfx layers at different times. I can't completely explain how it works in places, but feel free to ask about anything if you like!

This version has commented code in tab 0, but it is probably not a good example to get started with audio synthesis. For anyone game to try using 0x808, here is a simpler example that generates a sine wave at middle C (256Hz)

x=0
function _update()
  -- write one more byte while there
  -- is still space in the audio buffer
  while(stat(108) < stat(109)) do
    v = sin(x)*32 -- max vol:128
    x += 256 / 5512 -- middle c
    poke(0,mid(0,v+128,255))
    serial(0x808,0,1)
  end
end

Hey all! Time for some more bugfixes and esoteric features / QOL improvements to finish off 0.2.5*. And thanks to some snippets from @samhocevar's excellent z8lua, some cleaner code parsing. PICO-8 0.2.5d is now up on lexaloffle, Humble, itch.io, and for PocketCHIP and web (Education Edition).

0.2.5e

0.2.5e fixes a bug in the loader that causes uppercase characters to not be loaded as punyfont (e.g. breaking _ENV).

0.2.5d

Added: tline(bits) to set number of bits used for fractional part of mx,my,mdx,mdy (13 by default)
Added: ctrl+mousewheel to scroll code horizontally
Added: current bbs cartridge id shown in window title (config.txt show_cart_id_in_title to disable)
Added: poke(0x5f36, (@0x5f36)|0x80) to enable character wrap by default when printing
Added: blit_method in config.txt // Can use a software blitter by default (slower but more reliable)
Added: reminder when re-locating sprites that only the top half of map is altered by default
Added: draw boot sound as note glyphs on startup when sound is off
Changed: print() returns both max(cur_x), max(cur_y) and includes non-printed characters (e.g. tabs)
Changed: extcmd("folder") and extcmd("set_title", "foo") can now be used from bbs carts
Changed: Indexing a string out of range returns nil (was "")
Changed: Replaced most of pre-processor with Lua parser modifications based on z8lua (fixes various edge cases)
Changed: "a[foo()] += 1" only evaluates foo() once
Changed: out-of-bound tile values can be drawn using map(), tline()
Changed: extcmd("audio_rec") can record a maximum of 8 minutes (was no limit previously)
Changed: Rate limits are now per-minute: 10MB of log writes, 64 different files, 10 extcmd("folder")'s)
Fixed: Infinite tokens hack (was caused by now-replaced pre-processor)
Fixed: Only 4 controllers mapped to 0x5f00+76
Fixed: h toggles hexadecimal mode in gfx editor (should be ctrl-h -- h is to flip sprite horizontally)
Fixed: out-of-bounds value doesn't respect custom map size
Fixed: cutting or clearing a selection of sprites does not also clear the sprite flags
Fixed: P8SCII repeat-character command fails on zero repetions; ?"a*0bc" should print "ac", not "abc"
Fixed: pxa code compression inefficient when >= 32k matching triplets (typically "000")
Fixed: print() return value max(cur_x) returns 0 when max(cur_x < 0)
Fixed: holding menu button to force pause menu to open broken in binary exports
Fixed: copying / pasting in commandline doesn't respect punyfont character encoding
Fixed: (Manual) Steps 1 & 2 on how to move sprites in the map are in the wrong order
Fixed: Unhelpful / no error messages when the wrong format for HELP is used

Wooden Toy Joinery by zep [Click to Play]

Use the dpad to move head pieces around, join them to tiles (only some tiles join, and only on certain sides), and move your creation to the target area to complete each puzzle.

A wee game for Twelve Days of PICO-8 Christmas 2022. To get the full experience, play it from @TheTomster's menu cart!

Some scenes from other games in the collection:

Wooden Toy Joinery was a 3 day collaboration with my 9 year-old while visiting my folk's place in the south of New Zealand. Yesterday out of nowhere my Dad produced what looks to be one of the first BASIC programs I ever wrote (maybe.. 1985?). I didn't have access to a computer at the time, and this was before understanding what variables are. I suspect I was imitating a pick-a-path adventure code listing I'd seen, but applied to an action game.

A new year, a new fantasy machine! Picotron Playground is an experimental web version of Picotron's WIP runtime and API, bundled with a terminal and code editor in order to make some toy programs. You can read more about the goals of Picotron and its specifications in the FAQ:

https://www.lexaloffle.com/picotron.php?page=faq

Although I'm still mostly occupied with PICO-8 and Voxatron, I hope this will be a good way to chip away at the project and let future users try out the API in a low-stakes way before it is ready to go into production.

Launch Picotron Playground here:

https://www.lexaloffle.com/picotron.php?page=playground

Note: you'll need a US layout keyboard and there is no permanent storage, although the clipboard does work if you want to store some snippets. Please work on anything larger than toy programs at your own risk!

Running Demos

Demo programs will appear (and probably disappear!) over time to try out various API functionality. At the moment they are mostly simple graphics demos that can be loaded via the terminal:

/$ cd /demos
/demos$ ls
/demos$ load dots

CTRL-R to run it.
ESC ESC to get back into the editor
CTRL-L clears the screen (important!)
The "reset" command can be used to get the default palette back.

Using the API

The most interesting feature of Picotron's runtime is probably the gfx pipeline, which is documented here: https://www.lexaloffle.com/dl/docs/picotron_gfx_pipeline.html

If you'd like a quick way to load sprites, try copying and pasting from PICO-8 gfx editor and pass that as a string to userdata():

my_sprite = userdata"[gfx ... /gfx]"
spr(my_sprite, 100, 100)

There are some more examples of how to manipulate userdata in the FAQ.

Limitations

• There's no audio yet.
• There is provisional cpu cycle counting, but it is incomplete and infinite loops will still crash your browser. You can get the cpu with stat(1), but it currently also includes cycles used by system processes.
• Some of PICO-8's more forgiving behaviors do not not exist [yet?], including being able to divide by zero, and automatically converting floats to ints.
• The code editor is still a bit janky. Sorry!
• btn() works but just for a placeholder P1 6-button layout.

I think that's enough to poke around for now. If you have any questions please post them in this thread or ask me on mastodon as there isn't a Picotron sub-forum yet. I hope you enjoy it!

More bugfixin'

PICO-8 0.2.5f 0.2.5g is up now up on lexaloffle, Humble, itch.io, and for PocketCHIP and web (Education Edition).

v0.2.5g Changelog:

Fixed: tonum("123abc") returns 123 (should return nothing) // also breaks split(). regression in 0.2.5f
Fixed: draw_tabs not listed by CONFIG command

v0.2.5f Changelog:

Added: CONFIG DRAW_TABS 1 to show tab characters in code editor (previously required editing config.txt)
Changed: tokenizer recognises long comments / string using [=[ ]=] e.g. [==[ long string ]==]
Changed: Nested long comments and strings no longer allowed
Changed: x % 0 gives 0 (was x)
Optimised: software blitter now faster when using PocketCHIP, windowed raspi or blit_method 1
Fixed: infinite tokens exploit introduced in 0.2.5d (due to pre-processor changes)
Fixed: >>>= operator is a NOP (bug introduced in 0.2.5d)
Fixed: (raspi 32-bit) window not visible under Gameforce Chi / EmuELEC -- bug introduced in 0.2.5e
Fixed: s="x".."=" counts as 4 tokens instead of 5
Fixed: Running a cartridge containing meta data prints a memory allocation warning to stdout
Fixed: Code compressing to >= 32k reports size as (compressed_size & 0x7fff) resulting in corruped exports
Fixed: stat(54) loops when left-most channel is looping (should return total played ticks on current pattern)
Fixed: extcmd("audio_rec") maximum length is 2 minutes (meant to be 8 -- and now only applies to web)
Fixed: Frog Home crashes because of (now unsupported) "local x+=.." form. // INSTALL_GAMES for fixed version
Fixed: Starting P8SCII font height affects total line height even when no characters are printed in that font

It's Lovebyte this weekend, and I made a couple of size-coded intros for it. First up is an invite to another demoscene party: SESSIONS in C4 LAN 2023 SPRING, taking place in Shizuoka / Japan end of April. This one is 512 bytes, around 100 of which are for the music (don't wait for the drop!):

sessions 2023 invitro by zep [Click to Play]

I also tried a bunch of 64 byte intros based on poking semi-structured patterns into ram that could double as audio and visual data. This is the one that I submitted to the 64 byte compo:

attack_on_venus by zep [Click to Play]

t=9::_::i=t^4
poke(i,51&(t*(i>>9)*(i%64)/♥))
t+=1/♥
sfx(i)goto _

Here's a variation that has more of a horror feeling:

forest_horror by zep [Click to Play]

t=19::_::i=t^4
poke(i,
0xdb&(t*(i>>7)*(i%64)/♥))
t+=1/♥
sfx(i)goto _

If you want to try these in a browser, you can copy and paste them into PICO-8 Education Edition.

I didn't have time to make 128 byte & 256 byte entries, which happen to be the two compos that have their own dedicated fantasy console sections! But I'll definitely be back next year -- it's great to have a whole party focused on size-limited prods, and that is inspiring so many great pieces of work. There are more events happening tonight (Sunday, UTC) and you can catch them live on twitch or archived on youtube. You can find a schedule on the lovebyte website. Good luck to those taking part tonight! <3

Time For Lunch by zep [Click to Play]

Here's an orange and some sandwiches for The Wizard. Use the dpad (or cursors) to control the owl, and watch out for castle creatures. Also, take care of the basket ~~ if it hits a wall too hard, it might smash. Good luck!

This is a short game made for Ludum Dare vol.53

https://ldjam.com/events/ludum-dare/53/$366108

Hey All! I've been trucking on some Picotron stuff a bit lately, and I've added a lot of it to the current build of Picotron Playground which you can play around with in your browser here:

https://www.lexaloffle.com/picotron.php?page=playground

A quick recap for some context: Picotron is a fantasy workstation that aims to be extremely hackable and flexible. It is not quite in production yet, but an experimental web version is available ~ that's what "Picotron Playground" is. The desktop version of Picotron, with built-in dev tools + HTML exporter are planned for later this year.

For more background, see also: Part I: The release thread

Code Editor

The code editor is now implemented as a GUI component that anyone can embed in their own programs. This will make it easier to create things like bespoke programming toys and scriptable level editing tools. Have a look at /demos/proggy.p64 to see how this works (although, that api might change a little later). It is still janky, but now janky in a more powerful way!

cd /demos
load proggy.p64
--> CTRL-R

Click a button to load each snippet, and type for live changes. For example try copying and pasting the 'paint' snippet into the bottom of 'decay' or 'sand'.

Side note: proggy.p64 has multiple tabs open when you load it-- each of these is a running a separate process (edit /system/tools/code.lua). This way, tools can focus on having a single file open, and let the WM handle having multiple files open in a unified way.

Palette

The palette has changed a little since v7, and I think possibly this will be the finished Picotron system palette. 16 is a smidgen duller, 23~26 are slightly brighter, and 30 is now a much brighter magenta. I don't know if anyone has gone very deep into the palette yet, but here's the new version for reference:

It is possible to set RGB values for the palette in Picotron, but windowed applications will need to lean heavily on the default 32 colour palette, and I think it will often be used as a starting point for building other palettes.

Graphics API

The graphics pipeline design document now including a step-by-step summary of how a pixel is drawn (near the end): https://www.lexaloffle.com/dl/docs/picotron_gfx_pipeline.html

Indexed Display Palette

v.8 now includes an indexed display palette (64 bytes starting from 0x5480) similar to PICO-8's one. It defaults to an identity palette (0, 1, 2..) and so has no effect. The display palette provides an easier way to do palette swaps & cycles etc at the end of each frame without having to mess around with the RGB display palette.

Separate Target Mask for Shapes

Shape drawing functions (circfill etc) now get their own separate target_mask at 0x550b that defaults to 0. The target mask is applied to whatever value is already in pixel to be drawn over, so 0 means "don't care about what is already there". There are two reasons for this:

The first is that the default behaviour when drawing colour 0 is now for it to be drawn solid, while sprites can at the same time be drawn with transparency for colour 0. This is much more intuitive and also matches PICO-8's behaviour.

The second reason is that drawing horizontal spans can be optimized when not caring about what colour values are being drawn over: when target_mask is 0, each output value is only a function of the draw colour(s) and fill pattern. I've reduced the (fantasy) cpu cost in this case by 50% and can likely reduce it further later after optimising that code path.

Default Colour Table Stencil Bit Values

The behaviour of pal() and palt() have been changed to make it easier to set (and ignore) stencil bits:

https://www.lexaloffle.com/dl/docs/picotron_gfx_pipeline.html#Colour_Tables

(near the end of that section)

Setting palette entries

Instead of poking, you can use pal(1, 0xrrggbb, 2) to set rgb palette entries.

pal(1,0xff0000,2) -- too red
circfill(200,100,50,1)

It can also take a table of entries like PICO-8:

pal({0xff0000,0x00ff00,0x0000ff},2)
for i=1,3 do circfill(200 + i*50,100,20,i) end

PODs

PODs (Picotron Object Data) are strings that store the contents of Lua values, sort of like JSON. They're used for many things internally, but none of them are very relevant to Picotron Playground (yet?). v.8 includes some improvements to the POD format, and the result is that it will eventually possible to store images, maps and other data very quickly, with reasonable compression built in -- straight from the Lua object to disk and back again. If you're curious, you can find some details here:

https://www.lexaloffle.com/dl/docs/picotron_pod.html

Trivia: since the start of Lexaloffle I've been working with .pod files, generated by my in-house editing multitool called Poido (from "Pointy Dough" because it includes a low-poly modeller, but I use it mostly for bitmap editing and palette design). I thought that with Picotron I'd finally be free of pod files, but it turned out to be the most fitting name once again!

One thing you can try: paste this POD into the code editor and hit enter a couple of times to get an embedded image (that as legal lua source code returns the scrawled star sprite that is being shown in the editor).

--[[pod_type="image"]]unpod("b64:bHo0AO4AAAD8AAAAcXB4dQBAAAAEANABAAAAAwTw0B8d8C0uAwCwLD7wK17wKW7wKH4DAPEBJ57wJa7wJL7wI87wI97wIgMA_UEh7vAg-gHwCn6w-gLwCr5w-gPwCf4AMP4VcP4ogP4lsP4kwP4i4P4g8AH_HvAC-h3wBP4b8Ab_GPAJ-hbwCv4V8Az_FPAN-hPwDv4S8A-_EQQAABQAAAQA8CMN-gIwzvAN-gBgvvAN7oCu8AzuoJ7wC97QjvALvvACbvALjvAGXvAKfvAIXvAJfvAKXgkA8BEMXvAIPvAPTvAHPvARPvAHLvATLvAHHvAVDvAvDvD-gw==")

It is a userdata object compressed (first with RLE encoding and then with lz4) and then re-encoded back into a text-friendly form as base-64. Whenever you copy an object in Picotron (like a sprite or section of map), it will be encoded like this for easy sharing between programs and other users.

You might also notice some .info.pod files lying around -- these are used to store per-folder metadata but will eventually be hidden. Per-file metadata is stored within the pod format itself.

Other Stuff

• Proper CPU model -- infinite loops won't bring the system down, and each frame, the available CPU is shared around each process.

• 64-bit pokes: you can use poke8 / peek8 and the new peek operator *

• aliasing can be implemented by mounting files -- "ls" is now aliased as "dir"

• see /demos/stencil.p64 for an example of using stencil bits

• try out rnd_blend and/or stretch at the start of /demos/chonky.p64

fill pattern catalogue by zep [Click to Play]

This is a little tool for viewing all possible 4x4 fill patterns, after removing duplicates which are the same pattern inverted, translated, rotated, or flipped in x/y/diagonally. There are 65536 possible raw fill patterns (1 << 16), but only 433 unique patterns once "equivalent" ones have been discarded.

To use a fill pattern that you like, prefix it with "0x" (it is a hexadecimal number) and pass it fillp():

fillp(0x95a6)
circfill(64,64,40,0xacd)
fillp() -- reset

Press UP and DOWN to browse the catalogue, [X] to invert and [O] (z/c) to hide the info bar.

I don't know if there is a more efficient way to calculate groups (or the number of groups) for these equivalence relations, but PICO-8 is more than fast enough to brute force it, so that's what this cartridge does! For each 16-bit fill pattern, its group id (the "orbit") is calculated by applying every combination of transformation and returning the lowest result. If that value not already found in the list of patterns, it is added.

I was able to take a few shortcuts though -- for example, calculating 90 degree rotations is not necessary, because for every orientation there is a combinations of flipping in x, y and through the diagonal (transpose) that is equivalent to that rotation.

loom valley by zep [Click to Play]

X to accelerate -- try to stay on the ground to maintain speed!

This is a 1022 byte cartridge made for the pico-1k jam, but while I was commenting it I found a bunch of unused junk, so now it is 999 bytes compressed :) (see the code in tab 1, minified by @thisismypassword's excellent Shrinko8 )

pico1k entry page: https://itch.io/jam/pico-1k-2023/rate/2289420

Elf Curling by zep [Click to Play]

A wee game for the the 2023 Holiday Bundle: https://www.lexaloffle.com/bbs/?tid=55407

It is 2 player, but if you'd like to play around with both teams, you can enable 'hotseat' mode in the pause menu which allows using the same controls for both teams.

The goal is to get as many curling stones inside or even barely touching the red (5 points) and blue (2 points) circles, counted at the end of the match. Each elf is assigned a fixed amount of time to do whatever they like, including jumping on stones, riding them around, and pushing around the opponents' curling stones or players.

There are no points awarded for having elves in the circles at the end of the match -- it is just about the stones, for a maximum of 15 points. The last elf has the last-move advantage, but only 7 seconds instead of 10. The first 2 elves get 15 seconds each. Players can decide who goes first with a game of real-world rock paper scissors, and the first player to press X goes first.

Controls: [O] (z on the keyboard) to jump, dpad/cursors to skate around.
Both elves and stones start curling when they are spinning fast enough.

Hey All! PICO-8 0.2.6b is up now up on lexaloffle, Humble, itch.io, and for PocketCHIP and web (Education Edition). Note: you'll need to update to 0.2.6b to play new carts and SFX snippets created in 0.2.6!

Inverted Draw Operations

Thanks to @p01 for nudging me about this one! Filled draw operations (circfill, ovalfill, rectfill) can now be drawn inside-out: every pixel outside the area is drawn instead of every inside pixel. This can be controlled in a way similar to setting the fill pattern per draw call: first poke(0x5f34,0x2) to enable inverted draws, and then set bits 0x1800 in the colour argument. Here is a snippet to blank out everything except a circle in the middle (that changes size):

poke(0x5f34,0x2)
circfill(64,64,50+cos(t()/4)*10,0 | 0x1800)

And a short program that draws a tunnel:

function _draw()

    cls()
    poke(0x5f34,0x2)

    -- hold ❎ to skip fill
    cc = circfill
    if (btn(❎)) cc = circ

    for z=7,1,-1 do
        local sx = cos(z/15+t()/4) * 50
        local sy = sin(z/15+t()/4) * 50
        cc(64+sx/z,64+sy/z,64/z, 7+z | 0x1800)
    end
end

High Memory Video Mapping

Before 0.2.6, display memory and spritesheets could be mapped to each other (at 0x0000, and 0x6000). They can now also be mapped to one of the four high 2k sections at 0x8000, 0xa000, 0xc000, and 0xe000, as long as they don't overlap with the map mapping which takes precedence. There is a nominal cpu cost when a mapped region changes between graphics and map, but otherwise changing mappings is "free" apart from the poke() call overhead.

This was a previously rejected wishlist feature, but due to a bug discovered (and rightly abused!) by @StinkerB06, it seemed proper to offer this as a substitute before that bug is "fixed" in a future version. Well played!

Here's an example of moving the spritesheet to 0x8000 so that 0x0 can be used for something else. Just a reminder of a confusing gocha: remapping the spritesheet remaps the whole memory area 0x0..0x1fff. So once @0x5f54 is set to e.g. 0x80, even memory functions like memcpy, memset that operate on 0x0..0x1fff will be operate on 0x8000..0x9fff.

-- copy spritesheet to 0x8000
memcpy(0x8000,0x0,0x2000)
-- clear spritesheet at 0x0 to prove it is no longer used!
memset(0x0,0,0x2000)
-- remap spritesheet to 0x8000
poke(0x5f54,0x80)
-- draw something to prove it worked
spr(1, 50,50)

Waveform Instruments

Waveform instruments work roughly the same as SFX instruments: they each take up one SFX slot worth of data (SFX 0..7), and can be triggered from a regular SFX. But instead of treating the 64 bytes of note data as a regular SFX, they are used to represent 64 8-bit samples of a short looping waveform. Click on the new toggle button at the top right of the SFX editor to draw a waveform, and optionally pitch it an octave down with the "bass" toggle button. Waveform instruments can be used from inside SFX instruments, and also observe the detune, reverb and dampen filters.

Here are a couple of short demos (excuse the new WIP player -- it needs an initial tap to load it for browser compatibility). The first pattern shows some custom bass and lead instruments that are quite different from the built-in waveforms. Patterns 2&3 are more subtle, but those two instruments are also quite tonally different from any of the standard ones.

[sfx]

I think that doodling custom waveforms is great fun and opens up a new world of possibilities, but of course that in itself does set off alarm bells in terms of fantasy console design. I've come to view them as a worthwhile source of complexity that feels playful rather than overwhelming, and without creating a discontinuous jump in the "PICO-8 sound". Having said that, I'm sure I'll look back one day at earlier PICO-8 music with nostalgia for its particular simple charms. Here's a fitting tune by @ridgek to send off the old version!

Farewell, Fair Friend 🎈 by ridgek [Click to Play]

Music Scale Snapping

A low-key (ha!) feature of PICO-8 since very early on is that holding CTRL while drawing frequencies snaps each note to the C minor pentatonic scale. This is useful for both sound effects and music -- you can't really go wrong walking up and down (or jumping around) those 5 notes.

In 0.2.6, the scale that is snapped to while holding CTRL can now be customized in the music editor. There is a toggle button at the bottom right to switch between volume and scale snapping. Click on the keyboard to toggle scale selection mode. There are two buttons for transposing (<<, >>), 3 preset scales, and an invert button to get 3 more:

Dim   Diminished 7th    // invert to get a whole-half scale
Maj   Major scale       // invert to get pentatonic
Who   Whole tone scale  // invert to get.. the other whole tone scale

Changing the scale does nothing to alter the existing SFX -- it is applied only when holding CTRL and drawing frequencies.

A Little Music Theory

What is a scale anyway? Very roughly speaking, it is a selection of notes that are chosen to have a particular character or mood when used together. You might already be familiar with the scale formed by all of the white notes on a piano (or using keys qwertyu in PICO-8): C Major. Hit the Maj preset button to select this scale, and hold down CTRL to doodle a sound (spd:1) or melody (spd:16) in frequency mode.

Inverting the major scale (hit Inv) gives an Eb minor pentatonic scale, which is another name for all of the black notes. Try doodling some shapes again, and see how different that sounds. I think pentatonic scales are the most useful for starting out with melodies and sound effects, with its bright, resonant sound. To get from Eb minor pentatonic back to the default C minor pentatonic scale, hit << 3 times to transpose down 3 semitones. Examples of major and pentatonic scales are given in the first 2 patterns:

[sfx]

The other two scale presets also have their own distinctive character, with examples above in patterns 2..4. Who for a wholetone scale (every second semitone -- pattern 2), gives a floating ethereal feeling. Good for things like "falling down a hole" or "found a secret level". Dim for a 4-note diminished 7th scale (every third semitone -- pattern 3) gives something more unresolved ("entering a hidden chamber", or "a boss appears"). Inverting the diminished scale gives the whole-half diminished which has an even more mysterious quality that is more like "that lever triggered something but we don't know what it is yet".

These are oversimplified and silly examples, but I hope it gives you an idea of the kind of things you can explore with scales! If you'd like to know more, I highly recommend @Gruber's tutorial series that has a lot of handy music theory weaved in and also @bikibird's interactive music theory tutorials.

Handheld Improvements

With the rise of handheld devices like the RGB30 and Miyoo Mini Plus, there are many more handheld users of PICO-8 now (welcome aboard!). 0.2.6 has a few adjustments to make life easier:

Metadata Mending

When favouriting a bbs cart in 0.2.5g using the typical RGB30 / MM+ configuration, it was showing up as a local file with no metadata (blue cart icon instead of orange). Not a huge problem, but those carts can not show their full title, author and lose the ability to auto-update and find similar carts.

0.2.6 fixes that bug, and also deals with those carts by pinging the bbs for metadata when they are opened. So to "mend" such a bbs cartridge that has a blue label in the favourites list, just open it once while wifi is enabled.

merge_joysticks

This is an option in config.txt, that treats the first n controllers as if they were a single merged controller. This is useful in situations where you want to use the built-in buttons on a handheld device, but then later plug in a controller (e.g. when you connect it to a TV), but want that controller to also be used for the same player. To set up PICO-8 for such a system, use merge_joysticks 2 in config.txt.

Shutdown from Options

You can now close PICO-8 from the options menu while playing a game. This is handy for devices that do not have a 'kill app' option / button combination. Previously it was necessary to first exit to splore, then open a cartridge menu and use the options menu from there.

Miscellaneous

Mac Universal Binaries

PICO-8 now ships with native support for Apple silicon, as well as intel versions bundled as a universal binary. The exporters produce executables in that same universal format. To do this, I had to bump the minimum required MacOS to 10.8. I know there are still a few of you out there using PICO-8 on older Macs that will otherwise become doorstops. I don't have a good solution for this yet, but later on I'll look at setting up a legacy build system for such machines if there is sufficient demand.

Menuitem Button Filtering

By default, pause menu items creating using menuitem() respond to any button press, including left and right. This is handy in some situations (toggle buttons) but annoying or dangerous in others (clear game data). menuitem() can now take a bit mask in the high bits of the first parameter, indicating which button presses to ignore. Bits 0x100 and 0x200 mean LEFT and RIGHT, so if you can ignore those button presses with:

menuitem(0x301, "option 1", my_callback)

Improved Search

The search box in splore and on the bbs now returns more sensible results. Posts are sorted by number of stars, so if you type in "celeste", the first two results will be the original Celeste and Celeste 2. Imagine that! As a side-effect hack, you can search for " " and get an all-time highest starred cartridges list.

While working on search and scanning the BBS for preprocessor breakage, I made this collage of the 14 pages of featured cartridges that are now available (out of around 18k published carts). W00t! \o/

Preprocessor Removal

This is an internal change, but worth mentioning. 0.2.6 no longer uses a preprocessor at all (thanks to z8lua), so all of the code is running through a (modified) Lua 5.2 implementation as-is. Most of this happened in 0.2.5*, but there were a few leftover language features like short form print (using ?) and number parsing. 0.2.6 now also allows the use of "do" instead of "then" in if statements, which is something the preprocessor allowed (by accident!) and a number of early carts use it. There is a small amount of breakage of older carts that have things like unclosed or otherwise ill-formed comments that shouldn't be accepted. For those types of cases, I'm gradually working through older carts to make stealth fixes where needed. At this point the vast majority of existing carts should run as expected -- please do let me know if you see something weird that isn't a syntax error, which I can scan the BBS for automatically.

Socials

There are 2 new social usernames addable to your BBS profile: twitch.tv, and bluesky which is now open for signups without an invite. My social network of choice is still the fediverse / mastodon, but I think bluesky has the potential to coexist and be a nice place in the future ~ especially if they end up supporting gifs.

-> Add social handles to your profile

-> Find other lexaloffle users on bluesky / twitch

Changelog

That's all for now -- I'll catch you in a couple of weeks with a new machine!

BLORB (pico-1k) by zep [Click to Play]

BLORB LIKES CANS. GET CANS!

• DPAD / Cursors to Move
• Hold X to Grab / Retract
• Retract all the way back to the portal to collect a can.
• You only get 1 life ~ CTRL-R to restart if you crash (or open the menu with ENTER).
• There is no sound in space (I mean .. there is no space for sound)

Good luck!

This is a game made in 1024 bytes for PICO-1k Jam 2024, co-designed and pixelled by @castpixel (twitter). It is our third production as POD Design; you can find the first two here and here. BLORB is also up on itch and has a PICO-1K entry page. Thanks as always to @Liquidream for running this great jam, and @thisismypassword for the invaluable Shrinko8!

blorb.p8.rom as a hexdump because it looks good:
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There are comments in the source code of blorb-1 (use the "Code" pulldown under the cart player above). For the minified 1024 byte version: > LOAD BLORB-0

Technical Notes

As usual, to get this to fit in 1k some entertaining hackery and ugly code was required:

• A single loop is used to draw the nebula, stars and to decode the gfx from a string. The nebula lines are sometimes drawn over stars, making them twinkle -- a happy accident.

• One more loop is used to draw both the spacejunk and the chain segments. So the chain can never be longer than the maximum number of rocks / aliens.

• The eye of each alien is just the last drawn foot duplicated 10 pixels higher.

• A pixel under the player is sampled for colissions (colours 8~15). There are no "Objects" -- aliens only exist as drawn pixels.

• The same pixel is also tested when adding a new chain segment. If it is already the colour of the chain (4), the add() is skipped. So the shape of the segment character determines how frequently segments are added, and the retraction speed.

• The graphics are stored as a 320 character string, where each byte encodes 2 bytes in the spritesheet; bits 0xff are split into bits 0x3333. 44 is added to each encoded byte to get it to compress better. Less escape codes like \0 are needed in the string, and +44 happens to give a distribution of values that compress better with the surrounding code. Mistakes in the decoder produced many beautifully grotesque results like this one:

• The portal radius (pr) has many meanings: it is used for the chain colour so that it fades out as the portal opens and closes, and is used to determine the state of the game (large == playing, 0 == finished level, 0.1 == died). The player sprite colours are also set to the portal radius when colliding, so that it looks like it is getting sucked in and then eventually becomes hidden. Some alternative portals with varying byte costs:

Jar Life by zep [Click to Play]

Made for Ludum Dare 56.

Z/C to jump
X to bunch up / hoist / throw

Save 4 creatures in each room to progress to the next level (not everyone needs to make it out alive!). Grab a key to open the door, but the player can not enter until 4 creatures have passed through. To restart at any time, press ENTER and choose "restart level".

Have fun!

// by @kittenm4ster and @Minion

The GIF Gallery is a new corner of the BBS where GIFs & postcarts can be shared as separate items and live forever¹ in their uncompressed glory. Each profile page has its own GIF section, and there is a separate gallery for just the postcart GIFs:
https://www.lexaloffle.com/bbs/superblog.php?mode=gifs&postcarts=1

GIF posts don't show up in thread activity lists, so adding many separate GIFs is fine. I think it will be useful for things like tiny dev updates that are too small to be bloggy, gameplay captures, and archiving old tweetcarts. And of course some wee experimental ideas only really need to live as a gif rather than a whole cart. GIFs do show up in the superblog feed, and can be pinned to your profile page.

Click [here] to add a GIF. You can capture from any lexaloffle fantasy machine using ctrl-8, ctrl-9, or shift-ctrl-8 in Picotron to select a more squareish region.

Postcarts

Postcarts are tiny programs (300 chars or less), and can live on social media (#postcart on mastodon and bluesky), and now also the BBS: just include a code snippet when posting a gif and the code size and postcart tag are automatically added:

wish you were here

(300 chars)

::_::⧗=256for x=0,⧗ do
line(x,0,x-⧗,⧗,({12,7,8})[1+x\4%4])end
memset(25088,119,7168)pal(0,7,1)
?"\-f\^.⁘>⁘>⁘\0\0\0postcart\n\|j\-h300 chars",0,14,0
for n=0,799do x=n%40y=n\40
if(pget(x,y+10)<1)?chr(16+((y/3+x/2-t()*4)%6)),7+x*3,26+y*3,4
if(n<23)?chr(16+(n+t()*8)%8),8+n*5,20+n%2*82,6
end flip()goto _

// Don't worry, that code is not really meant to be readable.

I miss making tweetcarts, but don't feel particularly excited to make them for twitter anymore. Postcarts are an attempt to offer something in the same spirit, but that is platform independent and relatively eternal¹. After experimenting with a few sizes, I think 300 is fun to work with and a sweet spot in that neighborhood of round numbers. It is also nice that old tweetcarts can be reposted as-is to the BBS, and by sheer coincidence bluesky posts are 300 characters and use the same character counting as PICO-8 (🐱 is 1 char).

// by @luchak and @AndyMakes

Bluesky doesn't support uploading gifs directly but you can use something like cloudconvert to generate an mp4. Mastodon does convert automatically from gif, but the default quality is quite bad. If you are new to bluesky or the fediverse, don't forget you can find other lexaloffle folk via the superblog offsite pages.

If you're new to the world of size coding, you might light to check out @2darray's article on tweetcart optimisations, @PrincessChooChoo's Guide for Making Tweetcarts, and @TRASEVOL_DOG's doodle insights on how to make a twister. For more examples of what kind of programs are possible, check out @Munro's cart-ized tweetcart collection.

Physical Postcards

If you squint, postcarts and postcards are a really similar format! A nice picture on the front coupled with a short message that describes it / some short text.

If the postcarts collection becomes large enough over time, I'd love to print a bunch of them to display at Pico Pico Cafe (the place PICO-8 was named after and developed inside). The postcards would be square with a screenshot on the front and code on the back, and can be viewable on a special machine that scans the code and runs it. So it would feel a bit like thumbing through vinyls and choosing one to put on a record player.

If you would your postcart to be included in that collection, there is a checkbox for that while submitting. The more postcarts the merrier!

Thanks!

These projects were inspired by @AndyMakes' tweetcart gallery at Wonderville in Brooklyn, @Adam Atomic's OG tweetjam thread, the amazing world of tweetcarts that many folks have created over the years, and @Liquidream's excellent tweetcart archival account on mastodon.

¹by modern internet standards

Midnight Blue by zep [Click to Play]

Merry Christmas everyone! This winter, don't forget to spend quality time with your snowman friend. You can collect stars too if you like, but the real treasure is memories of whooshing through the snowy landscape together.

Use DPAD/cursors to fly around, and fly downwards for extra speed. After unlocking star mode, tab (or the pause menu) can be used to toggle it on -- press [O] (Z/C) to add a star and [x] to remove the last placed star. Toggle edit mode back off to return to collecting them.

Created for the 2024 PICO-8 Advent Calendar, which also comes as an itch collection. There are 25 great games in there, along with a lovely calendar cart by @SmellyFishstiks to explore them ~ check it out!