function expint(new_sig, new_exp) 
	local num = {}

	function num._step_up(steps)
		while steps > 0 do
			num.sig \= 10
			num.exp += 1
			steps -= 1
			if num.sig == 0 then -- we've lost all precision; for whatever we're doing, this number is as good as zero
				num.exp += steps
				steps = 0
			end
		end
	end

	function num._norm()
		while num.sig >= 10000 do
			num._step_up(1)
		end
		while num.sig < 1000 and num.exp > 0 do
			num.sig *= 10
			num.exp -= 1
		end
	end

	function num.add(val, sig)
		local to_add = expint(val, sig) -- be non-destructive with arithmetic; copy info into another expint to protect precision
		to_add._step_up(num.exp-to_add.exp) -- instead of doing any logic, just run step_up 
		num._step_up(to_add.exp-num.exp) -- on both the numbers. It'll only affect one of them.
		num.sig += to_add.sig
		num._norm()
	end

	function num.spend(val, sig)
		-- if val < num, subtracts val from num and returns true
		-- otherwise, returns false
		local to_spend = expint(val, sig)
		if to_spend.exp > num.exp or to_spend.exp == num.exp and num.sig < to_spend.sig then
			return false -- to_spend is greater than num; can't make the spend
		end
		to_spend._step_up(num.exp-to_spend.exp) -- instead of doing any logic, just run step_up 
		num._step_up(to_spend.exp-num.exp) -- on both the numbers. It'll only affect one of them.
		num.sig -= to_spend.sig
		num._norm()
		return true
	end

	function num.print()
--		local suffixes = split("K,m,g,T,P,E,Z,Y,R,Q") -- SI suffixes
		local suffixes = split("K,m,b,t,qU,qI,sX,sP,oC,nO,dE") -- number suffixes
		local return_string = num.sig
		if num.sig > 1000 then
			local modval = num.exp%3+1
			local suffix = num.exp\3+1
			if suffix > #suffixes then
				return_string = sub(return_string,1,1).."."..sub(return_string, 2).."X10^"..(num.exp+3)
			else
				return_string = sub(return_string, 1, modval).."."..sub(return_string, modval+1)..suffixes[suffix]
			end
		end
		return return_string
	end

	function num.save(cart_slot)
		dset(cart_slot, num.sig | num.exp>>16)
	end

	function num.load(cart_slot)
		num.sig = dget(cart_slot)\1
		num.exp = dget(cart_slot)<<16
	end

	num.sig = new_sig
	num.exp = new_exp or 0

	-- handle special cases: input can also be either an integer in string format or a table (assume it's another expint()!)
	if type(new_sig) == "string" then
		num.sig = tonum(sub(new_sig, 1, 4))
		num.exp = max(#new_sig-4, 0)
	elseif type(new_sig) == "table" then
		num.sig = new_sig.sig
		num.exp = new_sig.exp
	end

	num._norm()
	return num
end

This is a very very work-in progress planet generator. I'm not (yet) going for huge 
amounts of complexity or variation in my texture generator. Rather, right now, I'm
working to make as *performant* a planet generator and renderer as I reasonably can.

To generate terrain, I'm using the diamond-square algorithm to rende a 64x128 pixel
heightmap on the bottom half of the sprite sheet, which is mapped to the bottom half
of the PICO-8 map. To help ensure that we're not impacting performance, I've added some
break logic to the rendering routine that lets us stop processing once we hit a
certain CPU threshold, spreading the work across a few frames. This is fast enough that
planets render in well under a second, even with the added overhead of the break
logic.

Of note here is that planet generation is entirely deterministic and stems from a
single seed value. If you want to build a galaxy of planets, all you need to do is
store a number per planet and re-render them on the fly.

To render, I'm relying on tline to draw a linearly-banded UV map that reads from the
bottom half of PICO-8's map and draws a series of horizontal tlines across the unit
circle. At higher rotation rates, this is very obviously not an accurate way to draw
a sphere, but it *is* a blazingly *fast* way to do it, and at slow enough rotation
rates, it's good enough to fool the casual observer. Rendering times increase as the
planet grows, but even when the planet takes up most of the screen it only eats about
30% of the standard update cycle's CPU time.

Future improvements will be focused on adding some good variety to the planets being 
generated, along with features like polar regions and wind/precipitation-based biome
coloring.