SizeCoding - User contributions [en]

Main Page

2022-04-08T15:50:18Z

Childishbeat: Cleaned up with new article titles and better writing.

== Welcome to SizeCoding.org! ==

'''SizeCoding.org is a wiki dedicated to the art of creating very tiny programs for most popular types of CPUs. As sizecoding is also popular on other hardware, we recently opened the website for other platforms as well, check the links below.'''

By "very tiny programs", we mean programs that are '''256 bytes or less in size''', typically created by members of the [https://en.wikipedia.org/wiki/Demoscene demoscene] as a show of programming skill. The size of these tiny programs is measured by their total size in opcode bytes, and are usually presented as an executable binary.

'''Despite their tiny size, these programs are able to produce amazing graphical displays, playable games, and sometimes music.''' There are even some surprisingly effective programs in just '''16 bytes''' [https://demozoo.org/productions/?platform=&production_type=55] or even '''8 bytes''' [https://demozoo.org/productions/?platform=&production_type=54].

'''The intent of this wiki is to teach assembler programmers the various techniques used to create tiny demoscene intros.''' While these techniques can be used for other applications (boot sectors, ROM, BIOS and firmware code, etc.), the information presented here is firmly oriented towards the demoscene. Practicality and common sense are sometimes thrown out the window just to shave a single byte. Consider yourself warned.

Here is the list of active platforms available on this wiki:
*'''[[DOS]]''' - Sizecoding for x86/DOS.
*'''[[Linux]]''' - Sizecoding for Linux.
*'''[[ARM]]''' - ARM-based platforms (RISC OS, Game oy Advance, etc.)
*'''[[Motorola 68000]]''' - Start sizecoding for the Atari ST or Amiga.
*'''[[6502]]''' - Commodore 64, Atari XE/XL, Apple II, Atari 2600, Atari Lynx, etc.
*'''[[Z80]]''' - For all your ZX Spectrum, Amstrad CPC, etc. sizecoding needs.
*'''[[PDP-11]]''' - Get your BK-0010 and BK-0011 kicks here.
*'''[[RISC-V]]''' - Mainly on cheap microcontrollers or QEMU for now, but first RISC−V micro-processors based board come since one year.
*'''[[Fantasy consoles]]''' - Dedicated to fantasy consoles.
*'''[[Bytebeat]]''' - Tiny music created from mathematical expressions.
*'''[[High-level programming languages]]''' - Basically anything that controls the hardware less directly than assembly languages.

Motorola 68000

2022-04-08T15:43:56Z

Childishbeat: Childishbeat moved page Motorola 68k based CPUs to Motorola 68000: Less verbose

== Introduction ==
Wanting to start sizecoding on a Motorola 68k platform in this day and age can be tough.

So here is a bit of help to get you started:

=== The Motorola 68k processor ===
The Motorola 68k processor...

Note: Assigment direction is source,dest instead of dest,source !!!

==== Registers ====
To be added.

==== Instructions timing ====
The number of cycles for each instruction is different depending of processor model in M68K family.
: http://oldwww.nvg.ntnu.no/amiga/MC680x0_Sections/mc68000timing.HTML

== Motorola M68K Platforms ==
*'''[[Atari ST]]''' - Atari ST Sizecoding information
*'''[[Atari Jaguar]]''' - Atari Jaguar Sizecoding information
*'''[[Commodore Amiga]]''' - Commodore Amiga Sizecoding information

Motorola 68k based CPUs

2022-04-08T15:43:56Z

Childishbeat: Childishbeat moved page Motorola 68k based CPUs to Motorola 68000: Less verbose

#REDIRECT [[Motorola 68000]]

RISC-V

2022-04-08T15:42:21Z

Childishbeat: Childishbeat moved page RISC-V CPUs to RISC-V: Less verbose

== Introduction ==
RISC-V is an open and free standard or RISC ISA. It exists in 32,64 and still in draft stage, 128 bits wide versions. There are lot of free or non free implementations. You can find software, FPGA, or ASIC implementations on most codeforges like Github, Gitlab, Gitea, etc... Several research institute around the world also opened their own versions.

=== The RISC-V processor ISA ===
The RISC-V Processor is a RISC based architecture, with less instructions than most other RISC processors, as one the goal is to hardly shrink number of transistors. For example, there is no GT (>) or LE (<=) hardware instructions, only LT (<) or GE (>=) instructions, but GT and LE can be synthesized by switching it to LT/GE, and the registers in test to keep the test as needed. The only immediate value possible is coded on 12 bits. If the value is signed, the sign will be extended to the higher bit, of the size of the register. Several instructions are supported in RISC-V assembly language that doesn't actually exists as code machine instructions.

'''Warning:''' Generally less instruction in ISA (Instruction Set Architecture) as for RISC-V, means more instruction in machine code to have the same computation process, so RISC-V is not really competitive with other architectures for size-coding. It's advantage is more on transistors size-coding in its implementations, allowing more cores or more extensions than other architecture for the same die size, and a more efficient computation/power ratio. So there is also some [[LUT sizecoding]] tips, as used in the [https://github.com/kammoh/picorv32 PicoRV32 implementation] (ISC licensen similar to BSD one).

One of the main goals of the specifications is to have modularity with high granularity. So bitwise operators, multiplications/divisions, vector instructions for example are on different optional extensions, that can be implemented or not by RISC-V processor makers, reducing the total number of transistors depending on processor usage. Each extension have its own letter added in the name of the processor.

The specifications are all available on the risc-v.org site: https://riscv.org/technical/specifications/

==== Nomenclature and extensions ====
* RV|32/64/128|E/I/G: '''R'''isc'''V''', 32, 64 or 128 bits, base '''E'''mbedded/ '''I'''nteger/'''G'''eneral purpose instruction set

So you will see generally RV32I for 32bits version + other letters corresponding to extensions as defined below. RV32E means (still) reduced, embedded systems version of integer instruction set. RV32I or (RV64G) means RV32 or RV64 + '''G'''eneral purpose (including IMAFD + Zicsr+ Zifenci extension) as described below:

Basic '''standardized'' extension are:
* Zifencei: Instruction-Fetch Fence
* M: '''M'''ultiplication/division
* A: '''A'''tomic instructions
* Zicsr: Control and Status Register
* F: Single-precision '''F'''loating-Point
* D: '''D'''ouble-precision Floating-Point
* G: '''G'''eneral pupose (all of the above together)
* Q: '''Q'''uad-precision Floating-Point
* L: Decima'''l''' Floating-Point (IEEE 754-2008)
* C: '''C'''ompressed instructions
* B: '''B'''it manipulation
* J: '''J'''IT for dynamically translated languages
* T: '''T'''ransactional memory
* P: '''P'''acked SIMD instructions
* V: '''V'''ector instructions (as a vector processor, not as a packed SIMD)
* Zam: Misaligned Atomics
* Ztso: Total Store Ordering
* S: '''S'''upervisor-level Instruction-Set Extensions
* H: '''H'''ypervisor-level Instruction-Set Extensions
* X<name>: Non standard extension

* Crypto extension is frozen, and should be available in October.

=== Registers ===
Registers in assembly language can be called x0-x31 or by their specific functions. x0 is always 0 and can't be changed.

== Tools ==
==== Assembler, compiler, linker ====
* GNU tools contains both RISC-V 32 and 64bits compiler (GCC), assembler,linker,striper (gnu-binutils) and debugger (GDB), they are available for native or cross-compiling on most GNU/Linux distribution.

* [https://github.com/theandrew168/bronzebeard Bronzebeard] is a standalone assembler for developing bare metal RISC-V programs. It has been used mainly on Longan Nano a RV32 board generally sold with an LCD screen. There are few demo on this board. The initialisation of the screen on this platform has an important footprint that can't allow to go in 128B or 256B competitions.

* Arduino has several RISC-V implementations.

Most other languages are also available in RISC-V instruction set. Some Linux distribution have been ported and ISO are available (Debian, Ubuntu for example). Haiku OS also work on RISC-V platform, and there are plenty of embedded OS working on it (Arduino, FreeRTOS, HarmonyOS, LiteOS, RT-Thread, RustOS, Zephyr...).

=== Testing it ===
If you don't have one of those cheap boards, you can still test RISC-V assembly on an emulator.
Qemu allow to execute RISC-V application or systems on any kind of architectures. You can use the same tricks than used on x86 to reduce the binary size of the ELF binary format made with GNU tools.

The main author of Qemu also made [https://bellard.org/tinyemu/ TinyEmu], a RISC-V only tiny emulator, it already has WASM ports, so you can play with it on the web.

RISC-V CPUs

2022-04-08T15:42:21Z

Childishbeat: Childishbeat moved page RISC-V CPUs to RISC-V: Less verbose

#REDIRECT [[RISC-V]]

PDP-11

2022-04-08T15:42:06Z

Childishbeat: Childishbeat moved page PDP-11 CPUs to PDP-11: Less verbose

== Introduction ==
Wanting to start sizecoding on a PDP-11 platforms like the BK-0010 and BK-0011m in this day and age can be tough, especially if
you have not grown up with such a machine.

So here is a bit of help to get you started:

=== Registers ===
The PDP-11's registers are ALL 16 bit.

'''R0, R1, R2, R3, R4
R5 (Often Used to remember the return address during calls)
SP (R6), PC (R7)
'''
If an Even register number (R0,R2,R4) is used for certain commands (for example MUL)- the register and it's following will be used as a 32 bit pair when the result is returned

Assignment direction is left (source) to right (dest). Default number mode for the PDP-11 is Octal mode (base-8), but there is possible to use other modes as well

<syntaxhighlight>
mov #777,r0 ; octal =default
mov #^b101,r0 ; binary
mov #^x0aa,r0 ; hexadecimal
mov #'A,r0 ; ascii
</syntaxhighlight>

=== Instructions ===
Here is a rough translation for some of the PDP-11 instructions:

* MOV src,dest - move source int dest register
* CLR, CLRB - move zero into register
* INC/DEC , incb/decb - Increase/decrease register
* ADD/SUB - Add/Sub in 16 bits
* ADC/SBC - Add and Subtract in 32 bits
* MUL - 16 (odd register) or 32 bit (even register) multiplication
* DIV - 32 bit division
* ROL/ROR/ASR/ASL - Bit Rol and Shift instructions for 16 bit register
* ASH/ASHC - Shift 32bit register pair left and right (depending on argument)
* CALL/RETURN - Call subroutine, return to PC
* JSR/RTS<reg> - Jump subroutine / Return to address in register
* BIT - Bit test (can be used for AND)
* SWAB - Swap bytes in a 16bit register
* SXT - Sign extend a 16bit register into a 32bit pari
* COM - Complement register (flip all bit)
* NEG - Flip all bits and add 1 (negative)
* XOR - Exclusive OR
* BIS - Logical OR
* BIC - Inverse Logical OR (can be used as an AND instruction if performing a COM (bitflip) command first)

=== Testing and Branching ===
The PDP-11 has many branch conditions:
* TST - test register and update flags
* CMP - compare register
* BLT - branch if smaller (signed)
* BGT - branch if greater (signed)
* BLE - branch if smaller or equal (signed)
* BLO - branch if smaller (unsigned)
* BHI - branch if greater (unsigned)
* BLOS - branch if smaller or equal (unsigned)
* BHIS - branch if greater or equal (unsigned)
* BEQ - will branch if Z is set (Branch if EQual)
* BNE - will branch if Z is not set (Branch if Not Equal)
* BVS will branch if overflow is set
* BVC will branch if overflow is clear
* BMI will branch if the value is negative (minus - N set)
* BPL will branch if the value is positive (plus - N clear)
* BCS will Branch if Carry is Set
* BCC will Branch if Carry is Clear
* BR - this will ALWAYS branch

=== Learning PDP-11 Assembler ===
There are a couple of PDP-11 tutorials available online, but most of them are in russian. Here is a basic one:
* https://www.chibiakumas.com/pdp11/

== Electronika BK-0010 ==
The Electronika BK-0010 is a 16-bit PDP-11-compatible fanless Soviet home computers developed under the Electronika brand by NPO Scientific Center, the leading Soviet microcomputer design team at the time. It was also the predecessor of the more powerful UKNC and DVK micros.

=== Setting up ===
Setting up your development platform for the BK-0010/BK-0011m machine works as follows:

* Assembler: https://github.com/imachug/PDPy11
* Emulator: http://sandro.pdp-11.ru

=== Video display ===
Video display

=== Memory Map ===
To be added.

==== Getting something on screen ====
Now to get something on screen, lets fill our colorram with a simple AND pattern, like so:
<syntaxhighlight lang="z80">
to be added
</syntaxhighlight>

=== Sound ===
To be added.

=== Small demos with documented source code ===
* Mona Lisa for the BK-0010/11m https://www.pouet.net/prod.php?which=86820

=== Additional Resources ===
I found resources on BK-0010 sizecoding in english to be sparse.
* Good book to start BK-0010 programming http://www.translatetheweb.com/?from=&to=en&ref=TVert&dl=en&rr=DC&a=http%3a%2f%2fgid.pdp-11.ru%2fbooks%2fprogramming_BK10.html
* BK0010 ROM, system, etc http://www.translatetheweb.com/?from=&to=en&ref=TVert&dl=en&rr=DC&a=http%3a%2f%2fgid.pdp-11.ru%2fbooks%2f00001-01.32.03.html
* BK-0011M Information https://www.translatetheweb.com/?ref=TVert&from=&to=en&a=http%3A%2F%2Fgid.pdp-11.ru%2Fbooks%2F00015-01.32.01.html
* List of PDP-11 resources (Russian) http://gid.pdp-11.ru/doclist.html

PDP-11 CPUs

2022-04-08T15:42:06Z

Childishbeat: Childishbeat moved page PDP-11 CPUs to PDP-11: Less verbose

#REDIRECT [[PDP-11]]

ARM

2022-04-08T15:41:45Z

Childishbeat: Childishbeat moved page ARM based CPUs to ARM: Less verbose

== Introduction ==
So here is a bit of help to get you started:

=== The ARM processor ===
The ARM Processor is a RISC based architecture and comes in many flavors.

*'''[[RISC OS on ARM based CPUs]]''' - Create your tiny intro on ARM hardware on RISC OS.
*'''[[Gameboy Advance]]''' - Gameboy Advance Sizecoding Information

ARM based CPUs

2022-04-08T15:41:45Z

Childishbeat: Childishbeat moved page ARM based CPUs to ARM: Less verbose

#REDIRECT [[ARM]]

Z80

2022-04-08T15:41:21Z

Childishbeat: Childishbeat moved page Z80 based CPUs to Z80: Less verbose

== Introduction ==
Wanting to start sizecoding on a Z80 platform in this day and age can be tough.

So here is a bit of help to get you started:

=== Registers ===
The Z80 can be seen as the little 8-bit brother of X86 chipsets, with many similarities.
If you are coming from a X86 background, this might help you get a bit more grip on the Z80.
These are the register pairs of the Z80, as seen from a X86 programmers perspective.

* AF = AL + Flags
* HL = Can be seen as BX (H=BH,L=BL) or SI in a (HL) setting, like BX also used for addressing.
* BC = Can be seen as CX (B=CH,C=CL), often used for loops
* DE = Can be seen as DX (D=DH,E=DL) or DI in a (DE) setting
* IX = 16 bit Index Register X, can also be accessed with IXH,IXL
* IY = 16 bit Index Register Y, can also be accessed with IYH,IYL

For each of the main registers there also exists a shadow register. These cannot be accessed directly, but must be swapped in and out with the main register set. The shadow registers are usually denoted by the ' symbol. They can be swapped with the following commands:
* EX AF,AF' = Swaps AF with AF'
* EXX = Swaps BC, DE and HL with BC', DE' and HL'
There are no shadow registers for the index registers.

Note: For a lot of operations, you can only use the A(8bit) and HL(16bit) registers.
The Sjasmplus assembler has extra syntax and fake-instructions support which may produce unexpected results when source contains other than official Zilog syntax (but the parser can be configured to work in more relaxed way allowing more variations in syntax).

=== Instructions ===
Here is a rough translation for some of the Z80 instructions:

* BIT = TEST
* CP = CMP (although the Z80 has many other handy compare functionality)
* DJNZ = LOOP (decreases B and checks not zero)
* EXE = Exchange all registers with Shadow registers, can be used a bit like PUSHA/POPA
* EX = XCHG
* HALT = HLT
* JP = JMP
* JR = JMP NEAR (Jump Relative)
* LD = MOV
* LDI = MOVSB (tmp=(HL),(DE)=tmp, DE++, HL++)
* LDIR = REP MOVSB (tmp=(HL),(DE)=tmp, DE++, HL++, BC--)

=== Learning Z80 Assembler ===
There are many Z80 tutorials available online, but one i found very simple and clear is at this 1996 styled webpage ;-)

* http://www.z80.info/lesson1.htm
* http://www.z80.info/lesson2.htm
* http://www.z80.info/lesson3.htm
* http://www.z80.info/lesson4.htm
* http://www.z80.info/lesson5.htm

There is no proper index-page for this, which is why i linked all the lessons above, but you can continue to the next lesson by clicking at the next lesson at the bottom of the page.

Also, here is a compact 'cheat sheet' with some basics for various Z80 systems:
https://www.chibiakumas.com/z80/CheatSheet.pdf

== Z80 Plaforms ==
*'''[[ZX Spectrum]]''' - ZX Spectrum Sizecoding information
*'''[[Amstrad CPC]]''' - Amstrad CPC Sizecoding information

Z80 based CPUs

2022-04-08T15:41:21Z

Childishbeat: Childishbeat moved page Z80 based CPUs to Z80: Less verbose

#REDIRECT [[Z80]]

6502

2022-04-08T15:41:01Z

Childishbeat: Childishbeat moved page 6502 based CPUs to 6502: Less verbose

== Introduction ==
Wanting to start sizecoding on a 6502 platform in this day and age can be tough.

[[File:6502.jpg|thumb]]

So here is a bit of help to get you started:

=== The 6502 processor ===
The 6502 processor can be seen as the 8-bit micro ARM chip.
It has only has 3 registers (Accumulator, X and Y registers) and a handful of instructions to work with.

=== Adressing modes ===
To be added.

=== Zero page ===
When using the 6502 for sizecoding, you'll mostly be working from zeropage

=== General 6502 Resources ===
* 6502.org http://www.6502.org/
* 6502 instruction reference http://www.6502.org/tutorials/6502opcodes.html
* 6502 books http://retro.hansotten.nl/6502-sbc/
* 6502 Assembler tutorial https://dwheeler.com/6502/oneelkruns/asm1step.html
* Easy 6502 code tester https://skilldrick.github.io/easy6502/
* Synthetic instructions https://wiki.nesdev.com/w/index.php/Synthetic_instructions#8-bit_rotate

== 6502 Based Platforms ==
*'''[[Atari 8Bit]]''' - Atari 8-Bit Family (Atari XL/XE, etc.)
*'''[[Apple II]]''' - Apple II(e)
*'''[[Commodore 64]]''' - Commodore 64
*'''[[BBC Micro]]''' - Acorn BBC Micro/Master/Electron.
*'''[[Atari Lynx]]''' - Atari Lynx Handheld

6502 based CPUs

2022-04-08T15:41:01Z

Childishbeat: Childishbeat moved page 6502 based CPUs to 6502: Less verbose

#REDIRECT [[6502]]

Motorola 68000

2022-04-08T15:31:55Z

Childishbeat: Childishbeat moved page Motorola 68k based CPUS to Motorola 68k based CPUs: Misspelling

Motorola 68k based CPUS

2022-04-08T15:31:55Z

Childishbeat: Childishbeat moved page Motorola 68k based CPUS to Motorola 68k based CPUs: Misspelling

#REDIRECT [[Motorola 68k based CPUs]]

High-level programming languages

2022-04-08T15:31:12Z

Childishbeat: JavaScript has been readded after being removed from the fantasy consoles section.

This is a list of high-level programming languages with articles on SizeCoding.org.
==Programming languages==
*'''[[JavaScript]]'''

Fantasy consoles

2022-04-08T15:27:51Z

Childishbeat: Childishbeat moved page Fantasy Consoles to Fantasy consoles: Consistency

Welcome to the fantasy consoles section of the website, where we will cover fantasy consoles, like TIC-80, PICO-8 and MicroW8.
==Platforms==
*'''[[TIC-80]]'''
*'''[[PICO-8]]'''
*'''[[MicroW8]]'''
==See also==
* [[Byte Battle]]

Fantasy Consoles

2022-04-08T15:27:51Z

Childishbeat: Childishbeat moved page Fantasy Consoles to Fantasy consoles: Consistency

#REDIRECT [[Fantasy consoles]]

Fantasy consoles

2022-04-08T15:26:49Z

Childishbeat: Cleaned up. A new category will be used for high-level programming languages, hence JavaScript's removal, as it's one.

Bytebattles

2022-03-13T22:14:17Z

Childishbeat: Childishbeat moved page Bytebattles to Byte Battle: This is the spelling LoveByte, its inventor, uses, and article titles should use singular forms.

#REDIRECT [[Byte Battle]]

Byte Battle

2022-03-13T22:14:16Z

Childishbeat: Childishbeat moved page Bytebattles to Byte Battle: This is the spelling LoveByte, its inventor, uses, and article titles should use singular forms.

== Bytebattles ==

Bytebattles are a form of live coding, similar to Shader Showdowns, where two contestants compete in writing a visual effect in 25 minutes. The coding environment is the [[Fantasy Consoles|TIC-80 fantasy console]]. However, unlike Shader Showdowns, there is an additional limit: the final code should be 256 characters or less. This requires the contestants to use efficient code (e.g. single letter variables) and to minimize the code (e.g. remove the whitespace), all within the time limit. Unlike in normal TIC-80 sizecoding, there is no compression, so every character counts.

== General notation in this article ==

{|
! Symbol || Meaning
|-
| <code>i</code> || Pixel index
|-
| <code>s</code> || Alias for math.sin
|-
| <code>x</code> || Pixel x-coordinate
|-
| <code>y</code> || Pixel y-coordinate
|}

== Basic optimizations ==

* Functions, that are called three or more times should be aliased. For example, <code>e=elli</code> with <code>e()e()e()</code> is 3 characters shorter than <code>elli()elli()elli()</code>. Functions with 5-character-long names may already benefit from aliasing with two calls: <code>r=rectb</code> with <code>r()r()</code> is 1 character shorter than <code>rectb()rectb()</code>.
* <code>t=0</code> with <code>t=t+.1</code> is 3 characters shorter than <code>t=time()/399</code>.
* <code>for i=0,32639 do x=i%240y=i/240 end</code> is 2-3 characters shorter than <code>for y=0,135 do for x=0,239 do end end</code>.
* <code>(x*x+y*y)^.5</code> is 6 characters shorter than <code>math.sqrt(x*x+y*y)</code>.
* <code>s(w-11)</code> and <code>s(w+8)</code> both approximate <code>math.cos(w)</code>, so only <code>math.sin</code> needs to be aliased. <code>s(w-11)</code> is far more accurate, with the cost of one more character.

== One-lining ==

Most whitespace can be removed from LUA code. For example: <code>x=0y=0</code> is valid. All new lines can be removed or replaced with space, making the whole code a single line:

<syntaxhighlight lang="lua">
function TIC()for i=0,32639 do poke4(i,i)end end
</syntaxhighlight>

'''Warning: Letters <code>a-f</code> and <code>A-F</code> after a number cause problems.''' <code>a=0b=0</code> is not valid code. It is advisable to only used one letter variables in the ranges <code>g-z</code> and <code>G-Z</code> from the start; this will make eventual one-lining easier.

== Load-function ==

Function <code>load</code> takes a string of code and returns a function with no named arguments, with the code as its body. It's particularly useful for shortening the TIC function after one-lining:

<syntaxhighlight lang="lua">
TIC=load'for i=0,32639 do poke4(i,i)end'
</syntaxhighlight>

As a rule of thumb, one-lining and using the load trick can bring a ~ 275 character code down to 256.

<code>load</code> can be even used to minimize a function with parameters: <code>...</code> returns the parameters. For example, the following example saves 3 bytes:

<syntaxhighlight lang="lua">
SCN=load'r=...poke(16320,r)'
</syntaxhighlight>

Multiple parameters can be fetched with <code>x,y=...</code>.

'''Warning: The backslash causes problems when using the load trick.''' In particular, if you have a string with escaped characters in the original code e.g. <code>print("foo\nbar")</code>, then this needs to be double-escaped: <code>load'print("foo\\nbar")'</code>

== Dithering ==

If you have a floating point color value, TIC-80 <code>pix</code> and <code>poke4</code> functions round it (toward zero). To add dithering, add a small value, between 0 and 1, to the color. The best technique depends whether you have <code>x</code> and <code>y</code> available or only <code>i</code> and how many bytes you can spare:

{|
! Expression || Length || Result || Notes
|-
| || || [[File:No dithering.png]] || No dithering
|-
| <code>s(i)*i%1</code> || 8 || [[File:Random dithering.png]] || "random" dithering
|-
| <code>i*481/960%1</code> || 11 || [[File:Chess dithering.png]] || <code>(x/2+y/4)%1</code> if you have x&y. <code>i*25/96%1</code> or <code>i*97/192</code> if desperate.
|-
| <code>(x*2-y%2)%4/4</code> || 13 || [[File:Block dithering.png]] || 2x2 block dithering
|-
| <code>(i*2-i//80%2)%4/4</code> || 17 || [[File:Block dithering from i.png]] || 2x2 block dithering (almost), from i only
|}

A quick example demonstrating the 2x2 block dithering:

<syntaxhighlight lang="lua">
function TIC()
cls()
for i=0,2399 do
x=i%240
y=i//240
poke4(i,x/30+(x*2-y%2)%4/4)
end
end
</syntaxhighlight>

== Palettes ==

The following palettes assume that <code>j</code> goes from 0 to 47. Usually there's no need to make a new loop for this: just reuse another loop with <code>j=i%48</code>.

{|
! Expression || Length || Result || Notes
|-
| <code>poke(16320+j,j*5)</code> || 17 || [[File:Gray palette.png]] ||
|-
| <code>poke(16320+j,j%3*j*5)</code> || 21 || [[File:Blue-green-cyan palette.png]] || Good for objects & background
|-
| <code>poke(16320+j,j%3*j/.4)</code> || 22 || [[File:Blue palette.png]] || Use <code>(j+1)%3</code>, <code>(j+2)%3</code> or <code>2*j%3</code> for different colors
|-
| <code>poke(16320+j,s(j)^2*255)</code> || 24 || [[File:Rainbow palette.png]] || Change the phase of the palette with s(j+p)
|-
| <code>poke(16320+j,s(j)^2*j*6)</code> || 24 || [[File:Rainbow faded palette.png]] || Change the phase of the palette with s(j+p)
|-
| <code>poke(16320+j,s(j/15)*255)</code> || 25 || [[File:Blue-brown palette.png]] || <code>s(j/15)^2</code> is less bright
|-
| <code>poke(16320+j,s(j-j%-3)^2*255)</code> || 29 || [[File:Green-beige palette.png]] || <code>j%3*2</code> for a more blue/beige variant, <code>-j%3*4</code> for beige/blue variant
|-
| <code>poke(16320+j,255/(1+2^(4+j%3-j/5)))</code> || 35 || [[File:Bright beige palette.png]] || <code>2*j%3</code> for a pink variant
|-
| <code>poke(16320+j,255/(1+2^(5-j%3-j/5)))</code> || 35 || [[File:Bright blue palette.png]] || <code>2*j%3</code> for a green variant
|-
| <code>poke(16320+j,s(j/15+s(j%3*3))^2*255)</code>|| 37 || [[File:Green-purple palette.png]] || Cyclic, based on [https://iquilezles.org/www/articles/palettes/palettes.htm]
|}

The last one is an entire family of palettes. You can replace <code>s(j%3*3)</code> with any function that depends on <code>j%3</code>; this ensures the palette remains cyclic. Some ideas for tweaking the palettes:
* Invert the colors by adding a <code>-1-</code> in the expression
* Flip the blue/red channels & have the entire palette running backwards by using <code>poke(16367-j,...)</code>
* Abuse the default Sweetie 16 palette, by only setting some of the RGB channels, while keeping others as they are. For example, setting all the blue channels to zero: <code>poke(16322+j*3,0)</code>. Here <code>j</code> is between 0 and 15.

Code for testing palettes:

<syntaxhighlight lang="lua">
function TIC()
cls()
for j=0,47 do poke(16320+j,s(j/15)*255)end
for c=0,15 do rect(c*5,0,5,5,c)end
end
s=math.sin
</syntaxhighlight>

== Motion blur ==

In TIC-80 API, the <code>pix</code> and <code>poke4</code> functions round numbers towards zero. This can be abused for a motion blur: <code>poke4(i,peek4(i)-.9)</code> maps colors 1 to 15 into one lower value, but value 0 stays at it is. Like so:

<syntaxhighlight lang="lua">
function TIC()
t=time()/9
circ(t%240,t%136,9,15)
for i=0,32639 do poke4(i,peek4(i)-.9)end
end
</syntaxhighlight>

== Updating only some pixels ==

Pixel-based effects, especially raycasting and raymarching, can become excessively slow. A simple trick to update only ~ half of the pixels, giving a dithered/motion blur look and making the update smoother:

<syntaxhighlight lang="lua">
function TIC()
t=time()/499
for i=t%2,32639,1.9 do poke4(i,i/4e3+t)end
end
</syntaxhighlight>

== Examples of effects ==

The effects have not been crunched to keep them readable.

=== Plasma ===

<syntaxhighlight lang="lua">
function TIC()
t=time()/499
for i=0,32639 do
x=i%240
y=i/240
v=s(x/50+t)+s(y/22+t)+s(x/32)
poke4(i,v*2%8)
end
end
s=math.sin
</syntaxhighlight>

=== Rotozoomer ===

<syntaxhighlight lang="lua">
function TIC()
t=time()/999
a=s(t-11)
b=s(t)
for i=0,32639 do
x=i%240-120
y=i/240-68
u=a*x-b*y
v=b*x+a*y
poke4(i,(u//1~v//1)//16)
end
end
s=math.sin
</syntaxhighlight>

=== Tunnel ===

<syntaxhighlight lang="lua">
function TIC()
t=time()/199
for i=0,32639 do
x=i%240-s(t/7)*99-120
y=i/240-s(t/9)*49-68
u=math.atan2(y,x)*6/6.29
v=99/(x*x+y*y)^.5+t
poke4(i,u//1~v//1)
end
end
s=math.sin
</syntaxhighlight>

=== Raymarcher ===

The map is a bunch of repeated spheres here.

<syntaxhighlight lang="lua">
function TIC()
for i=0,32639 do
-- ray (u,v,w), not normalized!
u=i%240/120-1
v=i/32639-.5
w=1
-- camera origo (x,y,z)
x=3
y=0
z=time()/999 -- camera moves with time
j=0
repeat
X=x%6-3 -- domain repetition
Y=y%6-3
Z=z%6-3
-- ray not normalized=>reduce scale
m=(X*X+Y*Y+Z*Z)^.5/2-1
x=x+m*u
y=y+m*v
z=z+m*w
j=j+1
until j>15 or m<.1
poke4(i,j)
end
end
</syntaxhighlight>

== Additional Resources ==

* Code from past bytebattles https://livecode.demozoo.org/

JavaScript

2022-03-13T21:57:01Z

Childishbeat: Childishbeat moved page Javascript to JavaScript: To correct the spelling. Interestingly, the correct spelling sends you here without a redirect.

The Javascript sizecoding community has been quite active for years now.

=== Setting up ===

* Tools: [http://www.iteral.com/jscrush/ JSCrush online] [https://github.com/gre/jscrush JSCrush cli-tool] [https://siorki.github.io/regPack.html Reg Pack]
* Execution environment(s): Browser, [https://www.dwitter.net Dwitter]

=== Video display ===
No information yet

=== Sound ===

Something to get your journey started:

* [https://marcgg.com/blog/2016/11/01/javascript-audio/ Generate Sounds Programmatically With Javascript]

More information to follow

=== Additional Resources ===
* [https://js1k.com JS1k]

Tutorials / Postmortems

* [https://frankforce.com/i-made-7-demos-in-2-weeks-for-js1k/ I made 7 demos in 2 weeks for js1k]
* [https://nikhilism.com/post/2012/demystifying-jscrush/ Demystifying JSCrush]

More to follow

Javascript

2022-03-13T21:57:01Z

Childishbeat: Childishbeat moved page Javascript to JavaScript: To correct the spelling. Interestingly, the correct spelling sends you here without a redirect.

#REDIRECT [[JavaScript]]

Pico8

2022-03-13T21:24:50Z

Childishbeat: Childishbeat moved page Pico8 to PICO-8: PICO-8's the right spelling, and the page is inconvenient or harder to find with no ability to use it.

#REDIRECT [[PICO-8]]

PICO-8

2022-03-13T21:24:49Z

Childishbeat: Childishbeat moved page Pico8 to PICO-8: PICO-8's the right spelling, and the page is inconvenient or harder to find with no ability to use it.

The PICO-8 is a fantasy computer for making, playing and sharing tiny games and demos.

There are built-in tools for development: code, sprites, maps, sound editors and the command line, which is enough to create a mini retro game. At the exit you will get a cartridge file, which can be stored and played on the website.

Also, the game can be packed into a player that works on all popular platforms and distribute as you wish. To make a retro styled game the whole process of creation takes place under some technical limitations: 128x128 pixels display, 16 color palette, 256 8x8 color sprites and 4 channel sound

=== Setting up ===
The PICO-8 fantasy computer is an all-in-one creation and execution platform.

Unfortunately, the PICO-8 is a commercial package and should be purchased before you can get started.

You can go to https://lexaloffle.itch.io/pico-8 to purchase and then download the package for your platform of choice (Windows, OSX and even Raspberry Pi).

=== Getting started ===
PICO-8 programs are coded using the Lua scripting language.

The main function used for updating the screen (and called either 30 or 60 times a second) is the _DRAW() function, so this function is also a requirement for doing anything with graphics.

Most animated effects will also need to use some kind of a timer, so you are likely to also use the built-in time() function or keep track of your time (t) yourself as well. So a minimal setup would look something like this:

<syntaxhighlight lang="lua">
T=0 FUNCTION _DRAW()
-- your effect code
T=T+1
END
</syntaxhighlight>

Here is a single-image PICO-8 Cheat sheet to get you started.
<gallery>
PICO-8_Cheat_Sheet.png
</gallery>

=== Video display ===
The PICO-8 has a 128x128 pixel display with 16 colors which can be accessed via a wide range of graphics functions.

==== Built-in Draw functions ====
Here are a couple of built-in drawing functions you can use:
<syntaxhighlight lang="lua">
CLS(color=0)
PSET(x,y,color)
color=PGET(x,y)
CIRC(x,y,r,color)
CIRCFILL(x,y,r,color)
RECT(x,y,w,h,color)
RECTFILL(x,y,w,h,color)
LINE(x0,y0,x1,y1,color)
PRINT(text,[x,y,color])

COLOR(color) - Set default color
PAL(destindex,sourceindex) - Replace dest colorindex with color from sourceindex
FILLP(mask) -- Set fill pattern for circ, circfill, rect, rectfill, pset, and line
</syntaxhighlight>

==== Getting something on screen ====
Here is a bit of code to get you started:

<syntaxhighlight lang="lua">
T=0FUNCTION _DRAW()
FOR Y=0,128 DO FOR X=0,128 DO
PSET(X,Y,X~Y+T)
END END
T=T+1
END
</syntaxhighlight>

Which will display an animated XOR pattern.

==== Color Palette ====
Unfortunately for us sizecoders, the PICO-8 comes with a fixed palette of 16 colors with size-unfriendly color indexing (https://lospec.com/palette-list/pico-8).

Luckily, the PICO-8 provides a PAL(source,dest) function that lets you swap the color index of each color, but these are quite costly at 8-10 bytes per colorswap call.

==== Colorindex table ====
One of the easier ways to get a nice color-ramp without using the PAL function is to use a color indextable like so:

<syntaxhighlight lang=lua>
c={0,5,6,7}
pset(x,y,c[i])
</syntaxhighlight>

This method gives you the most freedom in terms of building your custom ramp of colors.

==== Color index shuffling ====
Alternatively, you can shuffle your color indices a bit to get 'somewhat workable' colors.

A couple of examples for this are:
* color+4 / pal(4,0) - Replaces color index 4 with 0(black) for a 4-shade Grayscale
* color&7*2 - Black, purple, brown, white
* (color&7)^2 - Black, blue, brown, yellow

But feel free to experiment yourself as well and let us know on Discord if you find something cool.

=== Sound ===
The PICO-8 does not allow you to poke the sound registers directly, but instead works with the SFX(effectindex) command to generate sounds. However we are allowed to poke the piece of memory that holds the sound effect data, like so:

<syntaxhighlight lang="lua">
POKE(12869+offset,value)SFX(1)
</syntaxhighlight>

=== PICO-8 vs TIC-80 Sizecoding ===
If you are familiar with TIC-80 sizecoding, but less with PICO-8. This chapter will help you point out the main differences between the 2 platforms:

* Performance on PICO-8 is more limited. The use of instructions/tokens (inside and outside loops) will have a performance/token penalty.
* Less code to work with (for a typical 256byte intro 229 characters vs 300-400 characters of LZ compressed code on the TIC-80)
* Code-editor = Escape (prepare to have your desktop filled with screenshots by accidentally pressing F1 ;-)
* All alphabetic letters can be tugged against numeric chars (0..9) on PICO-8
* Math functions don't need the MATH. prefix (SIN, COS, ATAN2, SQRT, SGN, RND, etc.)
* No integer divisions are needed anymore for logical operations
* The PICO-8 has custom characters available in the font (character numbers 128+).
* The PICO-8 Lua variant supports x+=value / x-=value
* The XOR operator is ^^ instead of ~
* FUNCTION _DRAW() = FUNCTION TIC()
* Warning: The POKE4 function pokes 4 bytes intro memory instead of a nibble. Nibble poke is not available.

=== Final optimisations and P8 Cartridge Release ===
When you are happy with your intro and want to get it ready for release, it becomes time to look at squeezing those last bytes.

Final optimisations can be done by stringing as much code together on single lines and removing any extra spaces and whitelines.

Here are a couple of other tips and tricks that help you squeeze those final bytes:

* You can always directly stick a letter A..Z after a number 0..9 or a bracket.
* Make sure to reorder variable assigments and code around to make use of optimal letter/number squeezing.
* Unlike the TIC-80 , no integer divides (like //1) are usually necessary for doing logical operations.
* Using a GOTO loop construction like ::L:: <yourcode> FLIP()GOTO L will save you 1 character over FUNCTION _DRAW() <yourcode> END
* You can alias functions that you are going to use more frequently, e.g. S=SIN or R=RND
* Using decimal values instead of hexadecimal will save 1 character (32768 vs 0x8000)
* Did you know that the T() shorthand version of the TIME() function is also available?
* Remember that ?"text",x,y is a shorthand for PRINT("text",x,y), however it does require its own newline (2x enter) to work

When you are done, make sure that your raw Lua character count is around the target size minus 27 characters, as most demoparties will accept a loadable .P8 cartridge file as an intro, which adds a 27 byte header like so:

<syntaxhighlight lang="lua">
pico-8 cartridge

__lua__
</syntaxhighlight>

Followed by your raw Lua code, so this leaves:
* 101 characters for a 128 byte intro.
* 229 characters for a 256 byte intro.
* 485 characters for a 512 byte intro.
* 997 characters for a 1024 byte intro.

The number of used characters can be made visible in the bottom right of the PICO-8 code editor, so that you can keep track.

You can edit the cartridge with the above header in an external editor or find and strip them down from your internal PICO-8 cartridge folder (type FOLDER to jump directly to your cartridge folder and/or edit the PICO-8 config.txt to save your P8 cartridge files elsewhere).

=== Additional Resources ===
Sizecoding on the PICO-8 is still in its infancy, but luckily there is already plenty of information to get you started!

* PICO-8 Wiki page http://pico-8.wikia.com/wiki/Pico-8_Wikia
* PICO-8 One page cheat sheet (PNG) https://imgur.com/iGrP5bK
* PICO-8 API Reference https://neko250.github.io/pico8-api/
* PICO-8 guide https://nerdyteachers.com/PICO-8/Guide/
* PICO-8 List of sizecoded Fantasy Console intros (PICO-8/TIC-80) https://www.pouet.net/lists.php?which=199

Tic80

2022-03-13T21:21:12Z

Childishbeat: Childishbeat moved page Tic80 to TIC-80: TIC-80's the correct spelling, and the page is inconvenient or harder to find.

#REDIRECT [[TIC-80]]

TIC-80

2022-03-13T21:21:11Z

Childishbeat: Childishbeat moved page Tic80 to TIC-80: TIC-80's the correct spelling, and the page is inconvenient or harder to find.

=== Setting up ===
As the TIC-80 fantasy computer is an all-in-one creation and execution platform, setting up TIC-80 is very easy:

Just go to the https://github.com/nesbox/TIC-80/releases page

and download the package for your platform of choice (Windows, OSX, Linux and even Raspberry Pi).

Or if you are just curious you can just start doodling online at http://tic80.com/

=== Getting started ===
Most TIC-80 programs are coded using the Lua Scripting language. However it is possible to select different scripting language like javascript at the cost of a couple of bytes/characters like so (respectively for JavaScript, MoonScript, Wren, Fennel, Squirrel):

<syntaxhighlight lang="js">//script: js</syntaxhighlight>
<syntaxhighlight lang="lua">-- script: moon</syntaxhighlight>
<syntaxhighlight lang="js">// script: wren</syntaxhighlight>
<syntaxhighlight lang="fennel">;; script: fennel</syntaxhighlight>
<syntaxhighlight lang="js">// script: squirrel</syntaxhighlight>

The main function used for updating the screen (and called 60 times a second) is the TIC() function, so this function is also a requirement for doing anything with graphics. Additionally you can also setup a sub=function SCN() that is called once per scanline at the costs of more bytes/characters.

Most animated effects will also need to use some kind of a timer, so you are likely to also use the built-in time() function or keep track of your time (t) yourself as well.. So a minimal setup would look something like this:

<syntaxhighlight lang="lua">
function TIC()t=time()
-- your effect code
end
</syntaxhighlight>

[https://github.com/nesbox/TIC-80/wiki/tic See here] to know how tic() is called in the different language supported by TIC-80.

A full overview of the TIC80 memory map and most common used function is available in this handy TIC80 cheatsheet, as well as the TIC80 wiki page.

https://zenithsal.com/assets/documents/tic-80_cheatsheet.pdf

=== Video display ===
The TIC-80 has a 240x136 pixel display with 16colors which can be accessed via a wide range of graphics functions or by writing directly to VRAM at memory address 0x0000 using the <code>poke4</code> instruction, that just change 4 bits. The address have to be multiplied by 2 when using poke4. access to 0x1000 for example is 0x02000 (high nibble) and 0x02001 (low nibble).

==== Draw functions ====
There are a couple of built-in drawing functions you can use:
<syntaxhighlight lang="lua">
cls(color=0)
pix(x,y[color]) [-> color]
circ(x,y,r,color) -- filled circle
circb(x,y,r,color) -- border circle
rect(x,y,w,h,color) -- filled rect
rectb(x,y,w,h,color) -- border rect
line(x0,y0,x1,y1,color)
tri(x1,y1,x2,y2,x3,y3,color)
textri(x1,y1,x2,y2,x3,y3,u1,v1,u2,v2,u3,v3,use_map=false,colorkey=-1)
print(text,x=0,y=0,color=15,fixed=false,scale=1,smallfont=false) -> width
</syntaxhighlight>

==== Getting something on screen ====
Here is a bit of code to get you started:

<syntaxhighlight lang="lua">
function TIC()
t=time()/99
for y=0,136 do for x=0,240 do
pix(x,y,(x>>3~y>>3)+t)
end;end;end
</syntaxhighlight>

Which will display an animated XOR pattern.

==== Color Palette ====
The best way to start is to use the default sweetie16 palette (https://lospec.com/palette-list/sweetie-16) as this palette
offers a nice selection of 16 colors arranged in such a way that they are easily accessable. From the verion 0.9b version and beyond you can initialise the new default sweetie16 palette at startup by adding a 0x11 Chunk to your TIC-80 cartridge.

Normally a chunk would contain 4 bytes of header + data, but as this chunk has no data, it is possible to omit the extra 3 bytes of chunk-header if you place it at the end of your TIC cartridge. The new TIC-Packer linked below has the option to do this for you.

==== Setting your own color palette ====
Alternatively you can setup your own palette by writing to the palette area located at 0x3fc0 like so:
<syntaxhighlight lang="lua">
for i=0,47 do poke (0x3fc0+i,i*5)end
</syntaxhighlight>
This produces a nice grayscale palette of 16 shades to work with.

==== Color index shuffling ====
If you don't want to use the sweetie16 palette you can revert back to the pre 0.8 db16 palette by simply not including a 0x11 chunk in you cartridge. Although the arrangement of color-indices is not as ideal as sweetie16, you can shuffle your color indices a bit to get 'somewhat workable' colors.

A couple of examples for this are
* (color)&10 - Some grey/blue shade
* ((color)&6)-3 - A Nice shade of Dark-cyan-white color
* (color)^2 - A shade of brown/yellowish colors

But feel free to experiment yourself as well and let us know on discord if you find something cool.

=== Sound ===
The TIC-80 has soundregisters and 32 byte waveforms to access which are located at address 0FF9C in memory.

<syntaxhighlight>
0FF9C SOUND REGS 72 18 byte x 4 ch
0FFE4 WAVEFORMS 256 16 wave/ 32x4b each
100E4 SFX 4224 64 sounds
</syntaxhighlight>

==== Make some noise ====
The easiest way to get 'some' sound going is to bitbang the sound-registers and hope for the best, for example:
<syntaxhighlight lang="lua">
TIC=function()for i=0,71 do poke(65436+i,(time()/7.2)%64)end end
</syntaxhighlight>

A more the "proper" way involves something like : define the waveform yourself (f.e. sawtooth), repeatedly (because for some reason one time is not enough), then write low part of the frequency to one byte, and the high nibble combined with the volume to another)
<syntaxhighlight lang="lua">
TIC=function()
for i=0,31 do poke4(2*65438+i,i/2) end -- setup waveforem
t=time()/10
-- write frequencies
poke(65436+0,t%256)
poke(65437+0,(t/65536)%16+240)
end
</syntaxhighlight>
But as you can see this costs considerably more bytes to setup.

=== Final Optimisations ===
When you are happy with your intro and want to get it ready for release, it becomes time to look at squeezing those last bytes.
As a goal-post, you should always aim to have your uncompressed effect around the target size, and work from there.

Final optimisation can be done by stringing as much code together on single lines and removing any extra spaces and whitelines.
A rule of thumb for this is that of the first or last character of a variable or function isn't a valid hex number (i.e. A-F) you can omit whitespace (so that: x=0 y=0 z=0 can become x=0y=0z=0)

=== Release ===
For releasing an intro at a demoscene event, a raw TIC cartridge file without any additional graphics/sound/metadata is needed.

Creating a http://www.sizecoding.org/index.php?title=Fantasy_Consoles&action=edit&section=13 TIC cartridge file adds a 4 byte header + 1 extra byte for a 0x11 sweetie16 chunk.

Luckily there are various packers that help you convert your (LUA) Script to a empty TIC Cartridge with a single ZLIB compressed code block and optional 0x11 (sweetie16) palette chunk. See the additional links for links to these packers.

==== Exporting Video as Animated GIF ====
The TIC80 environment has a neat feature that lets you export your intro directly as an animated GIF file to converted to video later, by Pressing the F9 key to start and stop recording. However, there is a default recording limit capped to a fixed number of frames or seconds. You can change this in the tic80 config to a bigger number to match your recording-size.

If your intro is taking up too many resources and starts chugging a bit on your machine, it can be wise to make a version that steps through time lineary by adding a number to your t variable yourself instead of using the time() function.

==== Online version: Metadata and Thumbnail image ====
When uploading the intro to the TIC80 website for a playable online version, you will need to build a new TIC file with some added some meta-data and Thumbnail image (You can take this screenshot using the F7 key during the demo playback) and use this as you online version. The screenshot can also be imported from a 240×136 PNG (other size will throw an error) using inside TIC-80 console <code>import screen file[.png]</code>.

The Meta data is added at the top of your intro as follows
<syntaxhighlight lang="lua">
-- title: My intro
-- author: scener
-- desc: my first sizecoded TIC-80 intro
-- script: lua (or moon/wren/js/fennel)
</syntaxhighlight>

Update: As of version 0.9b the TIC80.COM website now also allows you to upload a seperate TIC file with the metadata and keep the uploaded binary TIC file as code only.

=== Additional Resources ===
Sizecoding on the TIC-80 is still in its infancy, but luckily there is already plenty of information to get you started!

* TIC-80 Wiki page https://github.com/nesbox/TIC-80/wiki
* TIC-80 One page cheat sheet (PDF) https://zenithsal.com/assets/documents/tic-80_cheatsheet.pdf
* TIC-80 Intros and demos on Pouet (Press F1 for code): https://www.pouet.net/prodlist.php?platform%5B%5D=TIC-80
* TIC-80 TIC Cartridge File Format (from TIC-80 Wiki) https://github.com/nesbox/TIC-80/wiki/tic-File-Format
* TIC-80 Packer https://bitbucket.org/WaterEnVuur/tic80-packer/src/master/
* Pactic, fork de TIC-80 Packer https://github.com/phlubby/pactic
* TIC-Tool https://github.com/exoticorn/tic-tool