There are 128 global instruments defined at 0x40000 by default, each 512 bytes.

include("/appdata/system/lib/base64.lua")
print("Plain: abcdefg")
print("Base64: " .. base64.encode("abcdefg"))

base64.encode(string)
base64.decode(string)

----------------------------------------------------------------------------
-- print debugging based on IceCream for python
-- pico-8 lua version by jason delaat
do
   local ignore = {}
   local lookup = _ENV
   for k,_ in pairs(_ENV) do
      ignore[k] = true
   end
   local function format_arg(value, env)
      for k,v in pairs(lookup) do
         if v == value and not ignore[k] then
            return 'db: '..k..'='..tostr(v)
         end
      end
      return 'db: '..tostr(value)
   end

   local db_meta = {
      __call=function(self, value, log)
         if db.display and log then
            print(log)
         elseif db.display then
            print(format_arg(value))
         end
         return value
      end
   }
   db = {
      display = true,
      local_env = function(t)
         lookup = setmetatable(t or {}, {__index=_ENV})
         return lookup
      end,
      reset_env = function()
         lookup = _ENV
      end,
      wrap = function(f)
         local fn = sub(split(format_arg(f), '=')[1], 5)
         _ENV[fn] = function(...)
            local log = 'db: '..fn..'('
            local result = f(...)
            for a in all({...}) do
               log ..= tostr(a)..','
            end
            log = sub(log, 1, -2)
            log ..= ') --> '..tostr(result)
            return result, log
         end
      end
   }
   setmetatable(db, db_meta)
end
----------------------------------------------------------------------------

-- spr_from_atlas() - draw to the screen a slice of a sprite atlas
-- param: s - sprite atlas to use (the number in the Picotron spritesheet)
-- param: idx - the 0-based index to render from the atlas
-- param: cols - number of columns in the sprite atlas
-- param: rows - number of rows in the sprite atlas
-- param: x - screen x-coordinate to draw top-left corner of the sprite
-- param: y - screen y-coordinate to draw top-left corner of the sprite
-- param: flip_x (optional) - flip the sprite horiztonally
-- param: flip_y (optional) - flip the sprite vertically
function spr_from_atlas(s, idx, cols, rows, x, y, flip_x, flip_y)
    -- assign default values to optional parameters if nil
    local fx = flip_x ~= nil and flip_x or false

[ [size=16][color=#ffaabb] [ Continue Reading.. ] [/color][/size] ](/bbs/?pid=144162#p)

function _update()
	cls()
	print("hello",64,64,11)
end

function _update()
	print("hello",64,64,11)
	cls()
end

startup_folder = "/appdata/system/startup"
if fstat(startup_folder) == "folder" then
	for file in all(ls(startup_folder)) do
		filename = startup_folder .. "/" .. file
		if fstat(filename) == "file" and file:find("%.lua$") then
			create_process(filename)
		end
	end
end

--[[ vgfx.lua
vector graphics drawing

=== todo: ===
-more triangulation functions
-tween/interpolate between two vector sprites/polygons
-animation playback
-compression for vector data
-maybe look into userdata for optimisations
-maybe try writing directly to graphics memory if it's faster

also:
-make a vector sprite editor/animator app

=== docs: ===
"vector sprite": an array of polygons
"polygon": an array with 3 elements: color 1, color 2, vertices
"vertices": array of numbers (x0,y0, y1,y2, ...etc)

vertices list should be triangulated, sprv() will NOT triangulate arbitrary polygons

tri() and triraster() are decent triangle drawing functions, for lightweight
vector drawing, skip the vector sprite stuff and just use these

]]

vgfx_wire=false--enable for debug view of polygon triangles
vgfx_precise=false--enable if you have issues with edge seams

function make_polygon(col1,col2, verts)
	return {col1,col2,verts}
end

--vector sprite expectations:
-- array of polygons
-- each polygon is an array with:
--	color1, color2, vertices
--vertices expectations:
-- array of numbers (x0,y0, y1,y2, ...etc)
-- should be triangulated already - each three vertices will be drawn as a tri

--draw a vector sprite
function sprv(v, x,y, rot,scale, col)
	local s, cs = 0,0
	if rot and rot!=0 then
		s = sin(rot)
		cs = cos(rot)
	end

	if (col) color(col)
	for p=1,#v do--loop through each polygon in the vector sprite

		--prep to draw this polygon's colours
		if not col then
			fillp(0b1010010110100101)
			color((v[p][1]<<8)+v[p][2])
		end

		--third item in each polygon is a list of vertices (triangulated!)
		local t = v[p][3] 

		--draw each tri now
		local b=0
		local l=#t/6
		local v0 = {}
		local v1 = {}
		local v2 = {}
		for i=1, l do
			if rot and rot!=0 then
				v0 = rotvert(t[1+b],t[2+b],s,cs)
				v1 = rotvert(t[3+b],t[4+b],s,cs)
				v2 =rotvert(t[5+b],t[6+b],s,cs)
			else
				v0 = {x=t[1+b],y=t[2+b]}
				v1 = {x=t[3+b],y=t[4+b]}
				v2 = {x=t[5+b],y=t[6+b]}
			end

			if scale and scale!=1 then
				tri(x+v0.x*scale,y+v0.y*scale, x+v1.x*scale,y+v1.y*scale, x+v2.x*scale,y+v2.y*scale)
			else
				tri(x+v0.x,y+v0.y, x+v1.x,y+v1.y, x+v2.x,y+v2.y)
			end
			b+=6
		end
	end
	return tris
end

function rotvert(x,y,s,c)
	local v={}
	v.x=x*c-y*s
	v.y=x*s+y*c
	return v
end

function fan_triangulate(points)
	local v,i={},3
	while i<=#points do
		add(v,points[i].x)
		add(v,points[i].y)
		add(v,points[i-1].x)
		add(v,points[i-1].y)
		add(v,points[1].x)
		add(v,points[1].y)
		i+=1
	end
	return v
end

function strip_triangulate(points)
	if (#points<=3) return points

	local v,i={},4
	add(v,points[1].x)
	add(v,points[1].y)
	add(v,points[2].x)
	add(v,points[2].y)
	add(v,points[3].x)
	add(v,points[3].y)
	while i<=#points do
		add(v,points[i].x)
		add(v,points[i].y)
		add(v,points[i-1].x)
		add(v,points[i-1].y)
		add(v,points[i-2].x)
		add(v,points[i-2].y)
		i+=1
	end
	return v
end

vgfx_trisdrawn=0
function tri(x0,y0, x1,y1, x2,y2)
	vgfx_trisdrawn += 1

	if (vgfx_precise)	x0,y0,x1,y1,x2,y2 = flr(x0),flr(y0),flr(x1),flr(y1),flr(x2),flr(y2)

	--wireframe
	if vgfx_wire then
		fillp()
		line(x0,y0, x1,y1, 7)
		line(x1,y1, x2,y2, 7)
		line(x2,y2, x0,y0, 7)
		return
	end

	--order the vertices so they are descending from top to bottom
	--we need this since we are drawing it as two triangles:
	--one with a flat base, one with a flat top
	if (y1<y0) x0,x1=x1,x0; y0,y1=y1,y0
	if (y2<y0) x0,x2=x2,x0; y0,y2=y2,y0
	if (y2<y1) x1,x2=x2,x1; y1,y2=y2,y1

	--draw the top half
	local hh=y1-y0--height of the half
	local x3=x0+hh*(x2-x0)/(y2-y0)--slicing the tri in two makes another vertex
	if (y0!=y1) triraster(y0,y1, (x3-x0)/hh,(x1-x0)/hh, x0,x0)

	--draw the bottom half
	hh=y2-y1
	if (y1!=y2) triraster(y1,y2, (x2-x1)/hh,(x2-x3)/hh, x1,x3)
end

--draws a filled triangle line-by-line, top-to-bottom
--args: top, bottom, step left, step right, left pixel, right pixel
function triraster(t,b, sl,sr, pl,pr)
	for y=t,b do
		rectfill(pl,y,pr,y)
		pl+=sl
		pr+=sr
	end
end