SizeCoding - User contributions [en]

X68000

2025-06-04T09:48:32Z

Dresdenboy: additional book resource

== Sharp X68000 ==
The Sharp X68000 is a home computer created by Sharp Corporation. It was first released in 1987 and sold only in Japan.

The initial model has a 10 MHz Motorola 68000 CPU, 1 MB of RAM, and lacks a hard drive. The final model was released in 1993 with a 25 MHz Motorola 68030 CPU, 4 MB of RAM, and optional 80 MB SCSI hard drive. RAM in these systems is expandable to 12 MB, though most games and applications do not require more than 2 MB.

The X68000 has graphics hardware similar to arcade video games of the late-1980s, with custom coprocessors supporting scrolling, tiled backgrounds, and large numbers of sprites. Sound is supplied through multiple sound chips supporting 8 channels of FM synthesis and one channel of adaptive differential pulse-code modulation audio, which are mixed down to 2 analog stereo channels via a DAC chip. As such, video gaming was a major use of the X68000.

The X68000 runs an operating system called Human68k which was developed for Sharp by Hudson Soft. An MS-DOS-workalike, Human68k features English-based commands very similar to those in MS-DOS;

=== Setting up ===
* Assembler: VASM
* Tools: NDC to create an XDF Disk Image containing the production
* Emulator(s): http://retropc.net/pi/xm6/index.html , https://www.retrostic.com/emulators/sharp-x68000/winx68030

=== Memory map ===

<syntaxhighlight lang="">
address vector Function
$000000 $00 SSP after reset
$000004 $01 PC after reset
$000008 $02 Bus error
$00000c $03 Address error
$000010 $04 Unknown instruction
$000014 $05 Division by 0
$000018 $06 CHK instruction
$00001c $07 TRAPV instruction, FTRAPcc instruction
$000020 $08 Privilege violation
$000024 $09 Trace exception
$000028 $0a Unsupported instruction line 1010 emulator (SX call)
$00002c $0b ? line 1111 emulator (DOS call, floating point operation)
$000030 $0c Unused
$000034 $0d FPU ?????????????????
$000038 $0e ? ?????????????
$000034 $0d FPU Protocol violation exception handling
$000038 $0e Formatting error exception handling
$00003c $0f Uninitialized Interrupt
$000040 $10 Unused
$000044 $11 ?
$000048 $12 ?
$00004c $13 ?
$000050 $14 ?
$000054 $15 ?
$000058 $16 ?
$00005c $17 ?
$000060 $18 Spurious Interrupt
$000064 $19 Level 1 Interrupt (auto vector)
$000068 $1a ?
$00006c $1b ?
$000070 $1c ?
$000074 $1d ?
$000078 $1e ?
$00007c $1f ?
$000080 $20 trap #0
$000084 $21 ? #1
$000088 $22 ? #2
$00008c $23 ? #3
$000090 $24 ? #4
$000094 $25 ? #5
$000098 $26 ? #6
$00009c $27 ? #7
$0000a0 $28 ? #8 (reserved for system)
$0000a4 $29 ? #9 (OS debugger)
$0000a8 $2a ? #10 (reset & power off)
$0000ac $2b ? #11 (BREAK key)
$0000b0 $2c ? #12 (COPY key)
$0000b4 $2d ? #13 (CTRL+C)
$0000b8 $2e ? #14 (error processing)
$0000bc $2f ? #15 (IOCS call)
$0000c0 $30 FPU BSUN
$0000c0 $30 FPU BSUN
$0000c4 $31 ? INEX1,INEX2
$0000c8 $32 ? DZ
$0000cc $33 ? UNFL
$0000d0 $34 ? OPERR
$0000d4 $35 ? OVFL
$0000d8 $36 ? SNAN
$0000dc $37 ???
$0000dc $37 Unused
$0000e0 $38 MMU
$0000e4 $39 ?
$0000e8 $3a ?
$0000ec $3b Unused
$0000fc $3f Unused
$000100 $40 MFP RTC Alarm/1Hz
$000104 $41 MFP External power OFF
$000118 $42 MFP Front switch OFF
$00010c $43 MFP FM Audio source
$000110 $44 MFP Timer-D (Used with BG processing)
$000114 $45 MFP Timer-C (Mouse/cursor/FDD control, etc.)
$000118 $46 MFP V-DISP
$00011c $47 MFP RTC Clock
$000120 $48 MFP Timer-B
$000124 $49 MFP Key serial output error
$000128 $4a MFP Key serial output empty
$00012c $4b MFP Key serial input error
$000130 $4c MFP Key serial input
$000134 $4d MFP Timer-A
$000138 $4e MFP CRTC*IRQ
$00013c $4f MFP H-SYNC
$000140 $50 SCC(B) Transmission buffer empty
$000144 $51 SCC(B) ''
$000148 $52 SCC(B) External/status changes
$00014c $53 SCC(B) ''
$000150 $54 SCC(B) Incoming character validity (Mouse 1 byte input)
$000154 $55 SCC(B) ''
$000158 $56 SCC(B) Special Rx condition
$00015c $57 SCC(B) ''
$000160 $58 SCC(A) Transmission buffer empty
$000164 $59 SCC(A) ''
$000168 $5a SCC(A) External status changes
$00016c $5b SCC(A) ''
$000170 $5c SCC(A) Incoming character validity (RS-232C 1 byte input)
$000174 $5d SCC(A) ''
$000178 $5e SCC(A) Special Rx Condition
$00017c $5f SCC(A) ''
$000180 $60 I/O FDC status interruption
$000184 $61 I/O FDC insertion/discharge interruption
$000188 $62 I/O HDC status interruption
$00018c $63 I/O Printer ready interruption
$000190 $64 DMAC #0 End (FDD)
$000194 $65 DMAC #0 Error ('')
$000198 $66 DMAC #1 End (SASI)
$00019c $67 DMAC #1 Error ('')
$0001a0 $68 DMAC #2 End (IOCS _DMAMOVE,_DMAMOV_A,_DMAMOV_L)
$0001a4 $69 DMAC #2 Error ('')
$0001a8 $6a DMAC #3 End (ADPCM)
$0001ac $6b DMAC #3 Error ('')
$000200 $6c SPC SCSI interruption (Internal SCSI)
$000204 $6d Unused
$0003d4 $f5 Unused
$0003d8 $f6 SPC SCSI interruption (SCSI board)
$0003dc $f7 Unused
$0003fc $ff Unused
0x000000 RAM area
$c00000 Graphics Vram � Page 0
$c80000 Graphics Vram � Page 1 (256/16 color only)
$d00000 Graphics Vram � Page 2 (16 color only)
$d80000 Graphics Vram � Page 3 (16 color only)
$e00000 Text Vram � Bitplane 0
$e20000 Text Vram � Bitplane 1
$e40000 Text Vram � Bitplane 2
$e60000 Text Vram � Bitplane 3
$e80000 1.w R00 Horizontal total
$e80002 1.w R01 Horizontal synchronization end position timing
$e80004 1.w R02 Horizontal display start position
$e80006 1.w R03 Horizontal display end position
$e80008 1.w R04 Vertical total
$e8000a 1.w R05 Vertical synchronization end position timing
$e8000c 1.w R06 Vertical display start position
$e8000e 1.w R07 Vertical display end position
$e80010 1.w R08 External synchronization horizontal adjust: Horizontal position tuning
$e80012 1.w R09 Raster number: Used for raster interruption
$e80014 1.w R10 Text Screen X coordinate
$e80016 1.w R11 Text Screen Y coordinate
$e80018 1.w R12 Graphics screen Scroll X0
$e8001a 1.w R13 Graphics screen Scroll Y0
$e8001c 1.w R14 Graphics screen Scroll X1
$e8001e 1.w R15 Graphics screen Scroll Y1
$e80020 1.w R16 Graphics screen Scroll X2
$e80022 1.w R17 Graphics screen Scroll Y2
$e80024 1.w R18 Graphics screen Scroll X3
$e80026 1.w R19 Graphics screen Scroll Y3
$e80028 1.w R20 Memory mode/Display mode control
$e8002a 1.w R21 Simultaneous access/Raster copy/Quick clear plane select
$e8002c 1.w R22 Raster copy action: Raster number
$e8002e 1.w R23 Text screen access mask pattern
$e80481 1.b Active Image capture/Quick clear/Raster copy control
$e82000 256.w Graphics palette
$e82200 16.w Text palette (Palette block 0)
$e82220 240.w Sprite palette ('' 1-15)
$e82400 1.w R0 (Screen mode initialization)
$e82500 1.w R1 (Priority control)
$e82600 1.w R2 (Special priority/screen display) - Layers On/Off
$e84000 DMAC (HD63450)
$e86000 Memory controller privileged access settings (OHM/ASA)
$e88000 MFP (MC68901)
$e8a000 RTC (RP5C15)
$e8c000 Printer port
$e8e001 #1 Contrast
$e8e003 #2 Display/3D Shutter Glasses (Bit 0=Right Eye / Bit 1 = Left Eye)
$e8e005 #3 Color image unit (bit 4-0)
$e8e007 #4 Keyboard/NMI/dot clock
$e8e009 #5 ROM/DRAM Wait
$e8e00b #6 MPU Classification/Operation clock
$e8e00d #7 SRAM Write
$e8e00f #8 Unit power OFF
$E90001 FM Synthesizer (YM2151) - Register Address Write port
$E90003 FM Synthesizer (YM2151) - Data R/W port
$E92000 ADPCM (MSM6258V)
$E94000 Floppy disk controller (FDC) (uPD72065)
$E94005 Floppy drive monitor (IOSC)
$E96000 SASI
$E98000 ESCC (Z8530)
$E9A000 PPI (82C55)
$E9C000 I/O selector (IOSC)
$E9E000 I/O expansion area (Sharp reserved)
$EB0000 Sprite register (CYNTHIA)
$EB8000 Sprite VRAM
$EC0000 I/O expansion area (User)
$ed0072 2.b SX-Window environment flag (While in use with "SX")
$ed0074 1.b Standard double-click time / 10
$ed0075 1.b Mouse speed / 2
$ed0076 1.b Text palette hue (HSV)
$ed0077 1.b
$ed0078 1.b Brightness palette 0-3 5bit???
$ed007b 1.b Printer drive (PRTD) ID
$ed007c 1.b SRAM info version#, screen status storage, start screen storage
$ed007d 1.b Desktop background (PICT) ID
$ed007e 1.b Screen mode
$ed007f 17.b Reserved for system use (X68030)
$ed0090 1.b Standard cache status (bit=0: off 1:on)
$ed0091 1.b OPM music during startup (0: OFF -1: ON)
$ed0092 1.b 10MHz Proper wait value
$ed0093 1.b 16MHz ''
$ed0094 108.b Reserved for system use
$ed0100 768.b Head SRAM program address
$ed0400 15KB Head SRAMDISK address
$ed3fff End of SRAM
$ed4000 Backup (64KB)
$ee0000 Unused (128KB)
$f00000 CGROM(768KB)
$fc0000 SCSI IOCS / IPL(8KB)
$fe0000 ROM Debugger
$ff0000 IPL / ROM IOCS
</syntaxhighlight>

=== Video display ===
To be added

==== Vsync ====

<syntaxhighlight lang="">
waitVBlank:
move.w $e88000,d0
and.w #%00010000,d0 ;Wait for vblank to start
beq waitVBlank
waitVBlank2:
move.w $e88000,d0
and.w #%00010000,d0 ;Wait for Vblank to end
bne waitVBlank2
rts
</syntaxhighlight>

==== Plotting to screen ====
<syntaxhighlight lang="">
To be added
</syntaxhighlight>

=== Sound ===

The X68000 has a YM2151 FM Soundchip on board with 8 channels.
Each channel's sound can be built up with 4 different 'slots'... meaning there are a total of 32 slots... these slots are turned on or off when the sound is triggered

For more information, check out the YM2151 specs at [https://msxpro.com/datasheet.html]

=== Additional Resources ===
* [https://www.chibiakumas.com/68000/x68000.php Assembly programming for the X68000]
* [https://archive.org/details/X68000_488] X68000 Technical data book
* [https://msxpro.com/datasheet.html] YM2151 Datasheet
* [https://demozoo.org/productions/tagged/x68000/ X68000 demoscene productions]
* [https://archive.org/details/cpsystem/page/202/mode/2up X68000 chapter in the book "The Book of CP-System"]

Compression

2024-03-13T07:19:25Z

Dresdenboy: /* Available tools */ corrected description of pakettic features

This page covers compression related topics. This involves information about available tools on different platforms, platforms with compression support, compression algorithms and related decompression routines suited for the use in sizecoding, and ways to adapt code for better compression on different platform.

==Available tools==
{| class="wikitable sortable"
|-
! Name !! Platform !! Features !! Link
|-
| '''Pakettic''' || '''[[TIC-80]]''' ||
* metaheuristics based optimization of source code (e.g. names, operands, independent lines based on hints)
* applies known shorter code variants (e.g. function TIC -> TIC=load"...")
* optimization hints
* Zopfli based Deflate compression optimization
|| https://github.com/vsariola/pakettic/
|-
| '''tic-tool''' || '''[[TIC-80]]''' ||
* variable name optimization
* live heatmap of compressed source code to help identifying code parts, where changing the code might help
|| https://github.com/exoticorn/tic-tool
|-
| '''pactic''' || '''[[TIC-80]]''' || TBD || https://github.com/phlubby/pactic
|}

==Platforms with compression==
TBD

==Compression algorithms suited for sizecoded productions==
TBD

==Decompression routines and related resources==
TBD

==Code optimization for better compression==
TBD

Compression

2024-03-10T16:09:07Z

Dresdenboy: Initial page on compression

This page covers compression related topics. This involves information about available tools on different platforms, platforms with compression support, compression algorithms and related decompression routines suited for the use in sizecoding, and ways to adapt code for better compression on different platform.

==Available tools==
{| class="wikitable sortable"
|-
! Name !! Platform !! Features !! Link
|-
| '''Pakettic''' || '''[[TIC-80]]''' ||
* ML based optimization of source code
* optimization hints
* Zopfli based
|| https://github.com/vsariola/pakettic/
|-
| '''tic-tool''' || '''[[TIC-80]]''' ||
* variable name optimization
* live heatmap of compressed source code to help identifying code parts, where changing the code might help
|| https://github.com/exoticorn/tic-tool
|-
| '''pactic''' || '''[[TIC-80]]''' || TBD || https://github.com/phlubby/pactic
|}

==Platforms with compression==
TBD

==Compression algorithms suited for sizecoded productions==
TBD

==Decompression routines and related ressources==
TBD

==Code optimization for better compression==
TBD

Compression

2024-03-10T15:51:57Z

Dresdenboy: Initial page

MicroW8

2024-01-28T16:53:15Z

Dresdenboy: /* Sound */ Fixed a mistake

MicroW8 is a WebAssembly based fantasy console inspired by the likes of TIC-80, WASM-4 and PICO-8.

At the time of writing it currently is the most powerful fantasy console out there in terms of performance, code density, graphics and audio capabilities.

The initial motivation behind MicroW8 was to explore whether there was a way to make WebAssembly viable for size-coding. However the author also made sure that all design decisions make sense from the point of view of bigger projects as well.

=== Setting Up ===
MicroW8 is pretty lightweight and easy to setup. Just download the latest version of MicroW8 for you favorite platform at:
https://exoticorn.github.io/microw8/

After which you can open up your favorite editor and either open an existing example or create your own program.
The MicroW8 supports the following languages: CurlyWas, WASM (wat), C, Rust and Zig.

Then open up your console and type the following:

<syntaxhighlight>
uw8 run -w -p -l 9 myintro.cwa -o myintro.uw8
</syntaxhighlight>

This will compile, pack and start your intro in the microW8 environment and will watch the original sourcefile for any changes, so that upon saving the latest changes in your favorite editor, it will automatically compile, pack and relaunch your intro.

=== Graphics ===
The MicroW8 has a resolution of 320x240 pixels with 256 colors, accessable via framebuffer (located at memory address 120) or via primitive functions like setPixel, line, circle, rectangle.

The palette consists of 12 hues of 16 shades each, followed by a shiftable version of the sweetie16 palette in 1,2,4,8,16 and 32 color variants in the last 64 color indices.
[[File:Microw8pal.png|thumb|left|MicroW8 Default Palette]]

For full documentation on the graphics capabilities, check out https://exoticorn.github.io/microw8/docs/#graphics

=== Sound ===
The MicroW8 support sound via a custom soundchip (registers located at location 80 in memory) or via a dedicated soundcall for bytebeat.
Expect Sound capabilities somewhere in between the AY/YM chipset and a SID chip.

For full documentation on the sound capabilities, check out https://exoticorn.github.io/microw8/docs/#sound

=== Additional Resources ===
* [https://exoticorn.github.io/microw8/] MicroW8 website
* [https://exoticorn.github.io/microw8/docs/] MicroW8 Documentation
* [https://github.com/exoticorn/curlywas] CurlyWas Documentation
* [https://www.youtube.com/watch?v=u-OvsbDqLAY] MicroW8 Seminar

TIC-80

2024-01-03T18:35:14Z

Dresdenboy: /* Optimizing with a packer */ Moved the part about hiding the mouse cursor here

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

Setup is easy, simply download an executable from the [https://github.com/nesbox/TIC-80/releases releases] page 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 [https://www.lua.org/ Lua] scripting language. However it is possible to use different scripting languages at the cost of a couple of bytes/characters as shown below (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 (called 60 times a second) is the TIC() function, and is a requirement for animated graphics. Additionally you can also create a SCN() function that is called once per scanline at the cost 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 yourself. 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 learn how TIC() is called in the different languages supported by TIC-80.

A full overview of the TIC-80 memory map and most commonly used functions is available in this [https://zenithsal.com/assets/documents/tic-80_cheatsheet.pdf TIC-80 cheatsheet], as well as the [https://github.com/nesbox/TIC-80/wiki TIC-80 wiki page].

=== Video display ===
The TIC-80 has a 240x136 pixel display with 16 colors 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, setting four bits that represent a pixel's color. Note that the addresses have to be doubled when using poke4 because the memory is 4-bit addressable. Memory address 0x1000 would become 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 [https://lospec.com/palette-list/sweetie-16 sweetie16 palette] as this palette offers a nice selection of 16 colors arranged in such a way that they are easily accessible.
From version 0.9b onward you can initialize 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. Some packers linked below have the option to do this.

==== 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 sound registers and 32 byte waveforms to access which are located at address 0x0FF9C 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, 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 waveform
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 Optimizations ===
==== Optimizing with a packer ====
Packers will shorten variable names, remove excess whitespace, and reorder operators and statements to make the code short and highly-compressible.
It is therefore more important to write code that a packer can compress effectively as opposed to simply aiming for the smallest uncompressed code.

Repeating patterns within source code will typically be compressed very well.
Thus, it is best to use the same literals and reserved keywords as often as possible, while avoiding introducing new ones.
Additionally, if a variable or short function is used in multiple places, replacing each occurrence of the variable or function call with the calculation used to obtain their value will typically reduce cartridge size by a few bytes.

Tic-Tool provides an option for a live compression heatmap (in gzthermal style) to show, how well different parts of the code could be compressed.

With the appearance of a mouse cursor in version 1.0 one common question was, how it could be disabled efficiently. The clean way would be a poke(16379,0), but taking into account code compression, a shorter version might be possible by reusing similar code. Here is an example from "Danger Inbound" of reusing palette setup code:

<syntaxhighlight lang="lua">
-- set grey palette
for i=0,47 do
poke(16320+i,i*5)
end
-- switch off mouse cursor
-- (looks big, but due to compression and reusing palette code, this is just 5-6 bytes)
i=59 poke(16320+i,i*5)
</syntaxhighlight>

==== Optimizing without a packer====
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 optimization can be done by stringing as much code together on single lines and removing any extra spaces and newlines.
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)

Check the [[Byte Battle]] article for more optimization ideas.

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

Creating a TIC cartridge file adds a 4 byte header + 1 extra byte for a 0x11 sweetie16 chunk.
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 TIC-80 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 linearly 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 TIC-80 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 source code as follows
<syntaxhighlight lang="lua">
-- title: My intro
-- author: scener
-- desc: my first sizecoded TIC-80 intro
-- script: lua (or moon/wren/js/fennel)
-- license: MIT
</syntaxhighlight>

As of version 0.9b the http://tic80.com website now also allows you to upload a separate 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
* pakettic, https://github.com/vsariola/pakettic

TIC-80

2024-01-03T18:34:23Z

Dresdenboy: /* Optimizing without a packer */ moved the mouse cursor code to the section about optimizing with a packer

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

Setup is easy, simply download an executable from the [https://github.com/nesbox/TIC-80/releases releases] page 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 [https://www.lua.org/ Lua] scripting language. However it is possible to use different scripting languages at the cost of a couple of bytes/characters as shown below (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 (called 60 times a second) is the TIC() function, and is a requirement for animated graphics. Additionally you can also create a SCN() function that is called once per scanline at the cost 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 yourself. 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 learn how TIC() is called in the different languages supported by TIC-80.

A full overview of the TIC-80 memory map and most commonly used functions is available in this [https://zenithsal.com/assets/documents/tic-80_cheatsheet.pdf TIC-80 cheatsheet], as well as the [https://github.com/nesbox/TIC-80/wiki TIC-80 wiki page].

=== Video display ===
The TIC-80 has a 240x136 pixel display with 16 colors 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, setting four bits that represent a pixel's color. Note that the addresses have to be doubled when using poke4 because the memory is 4-bit addressable. Memory address 0x1000 would become 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 [https://lospec.com/palette-list/sweetie-16 sweetie16 palette] as this palette offers a nice selection of 16 colors arranged in such a way that they are easily accessible.
From version 0.9b onward you can initialize 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. Some packers linked below have the option to do this.

==== 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 sound registers and 32 byte waveforms to access which are located at address 0x0FF9C 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, 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 waveform
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 Optimizations ===
==== Optimizing with a packer ====
Packers will shorten variable names, remove excess whitespace, and reorder operators and statements to make the code short and highly-compressible.
It is therefore more important to write code that a packer can compress effectively as opposed to simply aiming for the smallest uncompressed code.

Repeating patterns within source code will typically be compressed very well.
Thus, it is best to use the same literals and reserved keywords as often as possible, while avoiding introducing new ones.
Additionally, if a variable or short function is used in multiple places, replacing each occurrence of the variable or function call with the calculation used to obtain their value will typically reduce cartridge size by a few bytes.

Tic-Tool provides an option for a live compression heatmap (in gzthermal style) to show, how well different parts of the code could be compressed.

==== Optimizing without a packer====
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 optimization can be done by stringing as much code together on single lines and removing any extra spaces and newlines.
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)

Check the [[Byte Battle]] article for more optimization ideas.

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

Creating a TIC cartridge file adds a 4 byte header + 1 extra byte for a 0x11 sweetie16 chunk.
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 TIC-80 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 linearly 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 TIC-80 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 source code as follows
<syntaxhighlight lang="lua">
-- title: My intro
-- author: scener
-- desc: my first sizecoded TIC-80 intro
-- script: lua (or moon/wren/js/fennel)
-- license: MIT
</syntaxhighlight>

As of version 0.9b the http://tic80.com website now also allows you to upload a separate 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
* pakettic, https://github.com/vsariola/pakettic

TIC-80

2024-01-03T18:33:22Z

Dresdenboy: /* Optimizing without a packer */ adding a paragraph about hiding the mouse cursor and a reference to the Byte Battle optimizations

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

Setup is easy, simply download an executable from the [https://github.com/nesbox/TIC-80/releases releases] page 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 [https://www.lua.org/ Lua] scripting language. However it is possible to use different scripting languages at the cost of a couple of bytes/characters as shown below (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 (called 60 times a second) is the TIC() function, and is a requirement for animated graphics. Additionally you can also create a SCN() function that is called once per scanline at the cost 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 yourself. 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 learn how TIC() is called in the different languages supported by TIC-80.

A full overview of the TIC-80 memory map and most commonly used functions is available in this [https://zenithsal.com/assets/documents/tic-80_cheatsheet.pdf TIC-80 cheatsheet], as well as the [https://github.com/nesbox/TIC-80/wiki TIC-80 wiki page].

=== Video display ===
The TIC-80 has a 240x136 pixel display with 16 colors 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, setting four bits that represent a pixel's color. Note that the addresses have to be doubled when using poke4 because the memory is 4-bit addressable. Memory address 0x1000 would become 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 [https://lospec.com/palette-list/sweetie-16 sweetie16 palette] as this palette offers a nice selection of 16 colors arranged in such a way that they are easily accessible.
From version 0.9b onward you can initialize 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. Some packers linked below have the option to do this.

==== 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 sound registers and 32 byte waveforms to access which are located at address 0x0FF9C 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, 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 waveform
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 Optimizations ===
==== Optimizing with a packer ====
Packers will shorten variable names, remove excess whitespace, and reorder operators and statements to make the code short and highly-compressible.
It is therefore more important to write code that a packer can compress effectively as opposed to simply aiming for the smallest uncompressed code.

Repeating patterns within source code will typically be compressed very well.
Thus, it is best to use the same literals and reserved keywords as often as possible, while avoiding introducing new ones.
Additionally, if a variable or short function is used in multiple places, replacing each occurrence of the variable or function call with the calculation used to obtain their value will typically reduce cartridge size by a few bytes.

Tic-Tool provides an option for a live compression heatmap (in gzthermal style) to show, how well different parts of the code could be compressed.

==== Optimizing without a packer====
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 optimization can be done by stringing as much code together on single lines and removing any extra spaces and newlines.
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)

With the appearance of a mouse cursor in version 1.0 one common question was, how it could be disabled efficiently. The clean way would be a poke(16379,0), but taking into account code compression, a shorter version might be possible by reusing similar code. Here is an example from "Danger Inbound" of reusing palette setup code:

<syntaxhighlight lang="lua">
-- set grey palette
for i=0,47 do
poke(16320+i,i*5)
end
-- switch off mouse cursor
-- (looks big, but due to compression and reusing palette code, this is just 5-6 bytes)
i=59 poke(16320+i,i*5)
</syntaxhighlight>

Check the [[Byte Battle]] article for more optimization ideas.

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

Creating a TIC cartridge file adds a 4 byte header + 1 extra byte for a 0x11 sweetie16 chunk.
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 TIC-80 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 linearly 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 TIC-80 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 source code as follows
<syntaxhighlight lang="lua">
-- title: My intro
-- author: scener
-- desc: my first sizecoded TIC-80 intro
-- script: lua (or moon/wren/js/fennel)
-- license: MIT
</syntaxhighlight>

As of version 0.9b the http://tic80.com website now also allows you to upload a separate 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
* pakettic, https://github.com/vsariola/pakettic

TIC-80

2024-01-03T18:18:51Z

Dresdenboy: /* Optimizing with a packer */ - added a remark to use compression heatmaps with tic-tool

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

Setup is easy, simply download an executable from the [https://github.com/nesbox/TIC-80/releases releases] page 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 [https://www.lua.org/ Lua] scripting language. However it is possible to use different scripting languages at the cost of a couple of bytes/characters as shown below (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 (called 60 times a second) is the TIC() function, and is a requirement for animated graphics. Additionally you can also create a SCN() function that is called once per scanline at the cost 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 yourself. 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 learn how TIC() is called in the different languages supported by TIC-80.

A full overview of the TIC-80 memory map and most commonly used functions is available in this [https://zenithsal.com/assets/documents/tic-80_cheatsheet.pdf TIC-80 cheatsheet], as well as the [https://github.com/nesbox/TIC-80/wiki TIC-80 wiki page].

=== Video display ===
The TIC-80 has a 240x136 pixel display with 16 colors 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, setting four bits that represent a pixel's color. Note that the addresses have to be doubled when using poke4 because the memory is 4-bit addressable. Memory address 0x1000 would become 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 [https://lospec.com/palette-list/sweetie-16 sweetie16 palette] as this palette offers a nice selection of 16 colors arranged in such a way that they are easily accessible.
From version 0.9b onward you can initialize 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. Some packers linked below have the option to do this.

==== 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 sound registers and 32 byte waveforms to access which are located at address 0x0FF9C 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, 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 waveform
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 Optimizations ===
==== Optimizing with a packer ====
Packers will shorten variable names, remove excess whitespace, and reorder operators and statements to make the code short and highly-compressible.
It is therefore more important to write code that a packer can compress effectively as opposed to simply aiming for the smallest uncompressed code.

Repeating patterns within source code will typically be compressed very well.
Thus, it is best to use the same literals and reserved keywords as often as possible, while avoiding introducing new ones.
Additionally, if a variable or short function is used in multiple places, replacing each occurrence of the variable or function call with the calculation used to obtain their value will typically reduce cartridge size by a few bytes.

Tic-Tool provides an option for a live compression heatmap (in gzthermal style) to show, how well different parts of the code could be compressed.

==== Optimizing without a packer====
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 optimization can be done by stringing as much code together on single lines and removing any extra spaces and newlines.
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 TIC cartridge file adds a 4 byte header + 1 extra byte for a 0x11 sweetie16 chunk.
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 TIC-80 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 linearly 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 TIC-80 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 source code as follows
<syntaxhighlight lang="lua">
-- title: My intro
-- author: scener
-- desc: my first sizecoded TIC-80 intro
-- script: lua (or moon/wren/js/fennel)
-- license: MIT
</syntaxhighlight>

As of version 0.9b the http://tic80.com website now also allows you to upload a separate 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
* pakettic, https://github.com/vsariola/pakettic

Platform comparison

2023-02-19T13:12:54Z

Dresdenboy: Added useful Wikipedia links

{| class="wikitable sortable"
|-
! Platform !! CPU !! Size efficiency (rough) !! Graphics !! Sound !! Memory !! Special hardware !! Special features
|-
| '''[[Commodore Amiga]]''' OCS/ECS || '''[[Motorola 68000]]'''@7.14MHz || medium || 320x256 - 640x512 up to 32 colors in 1-5 bitplanes (OCS) up to 64 colors in 6 bitplanes (ECS) || 4 PCM channels || 512 kB (OCS) 1024 kB (ECS) || Blitter with line drawing and fill Copper || OS Libs
|-
| '''[[Commodore Amiga]]''' AGA || 68020@14MHz - 68060@66+MHz FPU on higher models || medium || 320x256 - 1280x512 up to 256 colors in 1-8 bitplanes|| 4 PCM channels || 2048 kB || Blitter with line drawing and fill Copper || OS Libs
|-
| '''[[Atari ST]]'''/STE || '''[[Motorola 68000]]'''@8MHz || TBD || TBD || TBD || TBD || TBD || TBD
|-
| Atari Falcon 030 || CPU 68030@16MHz FPU 68882@16MHz DSP56001@32MHz || TBD || TBD || TBD || TBD || TBD || TBD
|-
| '''[[Atari Jaguar]]''' || '''[[Motorola 68000]]'''@13.3MHz || TBD || TBD || TBD || TBD || TBD || Gaming Console RISC graphics coprocessor
|-
| Example || Example || Example || Example || Example || Example || Example || Example
|-
| '''[[TIC-80]]''' || - (Lua interpreter on host system CPU) || high || 240x136, 16 colors || 4ch wavetables || 80 kB "chip" 64 kB Lua code unlimited amount of allocateable memory || - || fast graphics primitives
|-
| '''[[PICO-8]]''' || 32b fictional@8MHz (modified Lua interpreter on host system CPU with made-up cycle counts for Lua opcodes) || high || 128x128, 16 colors || 4ch synth + 5.5 kHz PCM || 64 kB "chip" min(64 kB Lua code, 15kB compressed size, 8k tokens) 2 MB Lua memory || - || fast graphics primitives powerful print()
|-
| Example || Example || Example || Example || Example || Example || Example || Example
|-
| '''[[ZX Spectrum]]''' || '''[[Z80]]'''@3.5MHz || high || 256×192 with color attributes per 8x8 block || 1b sound or 3ch AY-3-8912 soundchip || 16-128 kB || - || Helpful ROM routines incl. FP calculator engine
|}

===== Additional Ressources =====

https://en.wikipedia.org/wiki/List_of_home_computers 
https://en.wikipedia.org/wiki/List_of_home_computers_by_video_hardware

Platform comparison

2023-02-18T13:58:39Z

Dresdenboy: Atari Jaguar updated, Atari Falcon added, minor edits

Platform comparison

2023-02-18T13:32:09Z

Dresdenboy: added more Amiga details, some first Wiki links, minor edits

{| class="wikitable sortable"
|-
! Platform !! CPU !! Size efficiency (rough) !! Graphics !! Sound !! Memory !! Special hardware !! Special features
|-
| '''[[Commodore Amiga]]''' OCS/ECS || '''[[Motorola 68000]]'''@7.14MHz || medium || 320x256 - 640x512 up to 32 colors in 1-5 bitplanes (OCS) up to 64 colors in 6 bitplanes (ECS) || 4 PCM channels || 512 kB (OCS) 1024 kB (ECS) || Blitter with line drawing and fill Copper || OS Libs
|-
| '''[[Commodore Amiga]]''' AGA || 68020@14MHz - 68060@66+MHz FPU on higher models || medium || 320x256 - 1280x512 up to 256 colors in 1-8 bitplanes|| 4 PCM channels || 2048 kB || Blitter with line drawing and fill Copper || OS Libs
|-
| '''[[Atari ST]]'''/STE || '''[[Motorola 68000]]'''@8MHz || Example || Example || Example || Example || Example || Example
|-
| '''[[Atari Jaguar]]''' || Example || Example || Example || Example || Example || Example || Example
|-
| Example || Example || Example || Example || Example || Example || Example || Example
|-
| '''[[TIC-80]]''' || - (Lua interpreter on host system CPU) || high || 240x136, 16 colors || 4ch wavetables || 80 kB "chip" 64 kB Lua code unlimited amount of allocateable memory || - || fast graphics primitives
|-
| '''[[PICO-8]]''' || 32b fictional@8MHz (modified Lua interpreter on host system CPU with made-up cycle counts for Lua opcodes) || high || 128x128, 16 colors || 4ch synth + 5.5 kHz PCM || 64 kB "chip" min(64 kB Lua code, 15kB compressed size, 8k tokens) 2 MB Lua memory || - || fast graphics primitives powerful print()
|-
| Example || Example || Example || Example || Example || Example || Example || Example
|-
| '''[[ZX Spectrum]]''' || '''[[Z80]]'''@3.5MHz || high || 256×192 with color attributes per 8x8 block || 1b sound or 3ch AY-3-8912 soundchip || 16-128 kB || - || Helpful ROM routines incl. FP calculator engine
|}

Platform comparison

2023-02-17T17:33:27Z

Dresdenboy: Initial table with some first entries

{| class="wikitable sortable"
|-
! Platform !! CPU !! Size efficiency (rough) !! Graphics !! Sound !! Memory !! Special hardware !! Special features
|-
| Amiga OCS || 16b/32b 68000@7.14MHz || medium || 320x256 1-5 bitplanes || 4 PCM channels || 512 kB || Blitter Copper || Libs
|-
| Example || Example || Example || Example || Example || Example || Example || Example
|-
| TIC-80|| - (Lua interpreter on host system CPU) || high || 240x136, 16 colors || 4ch wavetables || 80 kB "chip" 64 kB Lua code unlimited amount of allocateable memory || - || fast graphics primitives
|-
| Example || Example || Example || Example || Example || Example || Example || Example
|-
| ZX Spectrium || 8b Z80@3.5MHz || high || 256×192 with color attributes per 8x8 block || 1b sound or 3ch AY-3-8912 soundchip || 16-128 kB || - || Helpful ROM routines incl. FP calculator engine
|}

Motorola 68000

2023-02-06T21:24:31Z

Dresdenboy: Added 2 resource links related to Easy68k

== 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 is a 16-bit Big-Endian format processor, using 32-bit register and addresses.

This means that instruction sizes on average are either 2 or 4 bytes each, and 6 bytes for longword / 32-bit instructions.

Note: The assigment direction is source,dest instead of dest,source !!!

==== Registers ====

* D0..D7 - 8 x 32 bit General Purpose Registers

* A0..A6 - 7 x 32 bit Address Registers

* A7 - 32-bit Stack-Address Register

==== 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

== Size considerations ==
Here are some general rule of thumbs when it comes to size consideration when programming the M68000

* Moving/Calculating Register from/to registers - 2 bytes
* Moving/Calculating with byte or word values - 4 bytes
* Moving/Calculating with long values - 6 bytes

Shorter variants:
* moveq #value, reg : 2 bytes - Moves a values -128...127 to a register
* addq #value, reg : 2 bytes - Adds a values 0..8 to a register
* subq #value, reg : 2 bytes - Subtracts a values 0..8 from a register

== Resources ==
* [http://www.beycan.net/eklenen/M68000_Instruction_Set.pdf M68000 Instruction Set]
* [http://www.easy68k.com/ EASy68K Editor/Assembler/Simulator for the 68000]
* [http://www.easy68k.com/paulrsm/index.html Various Motorola 68k resources]

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

Z80

2021-05-02T22:23:55Z

Dresdenboy: /* Make some noise - AY */ fixed a typo

== 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 doesn't really do proper syntax checking for this so beware.

=== 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

== ZX Spectrum ==
The ZX Spectrum consists of a Z80A @ 3.5 MHz CPU with either 16k, 48k or 128K of RAM. Most demos are targeted at the Spectrum 128 because it includes more memory, a shadow screen buffer and an AY soundchip. The different models have slightly different timings - this will cause issues if you are doing cycle-exact effects like multi-color.

=== Setting up ===
Setting up your development platform for the ZX Spectrum is quite easy, first get the following tools:

* Assembler: SJASMPLUS -This assembler has nice macros for creating Binaries and SNA snapshot files out of the box. You can download it at https://sourceforge.net/projects/sjasmplus/
* Pasmo - for the .TAP create. Available at : http://pasmo.speccy.org
* Emulator(s): I Found [https://www.zophar.net/sinclair/zx-spin.html ZX Sping], [https://sourceforge.net/projects/fuse-emulator/ FUSE], [https://sourceforge.net/projects/unrealspeccyp/ UnrealSpeccy] and [https://www.aptanet.org/eightyone/ EightyOne] to work best for my usecase. Most emulators can read TAP, SNA and TRD files out of the box.

=== Start values ===
Upon startup (when called from basic), the following values can assumed:

* The alternate HL register is set to 0x2758
* BC = start address
* A = C

=== Video display ===
Video display on the ZX Spectrum is mostly CPU based with little hardware features. No hardware sprites, no specific text or video modes, only a 256x192 byte screenbuffer with 1bit pixeldata located at $4000 in memory.
It is ordened a bit strange in 3 sections of 256x64 pixels, then character rows, then subrows.

Address = 010RRLLL RRRCCCCC

* where RRRRR is the row number (0..23)
* CCCCC is the column number (0..31)
* LLL is the line number within the cell (0..7)

Calculating a screen address from XY coordinates is complicated due to the weird screen layout. In a larger demo you would generate a lookup table - it's usually best to avoid such calculations in small demos, but it can be done in under 30 bytes, eg: http://www.breakintoprogram.co.uk/computers/zx-spectrum/screen-memory-layout

==== Adding Color ====
The ZX Spectrum has a 32x24 colormap located at $5800 where you can write color information for each 8x8 tile.
It has has 8 colors (INK and PAPER) with 2 brightness settings that can be set like this.

color = brightness(64) | (PAPER<<3) | INK

Because updating pixel memory can be slow, especially when you are grasping for bytes, some of the tiny intros on the zx spectrum prefer to use the colorram for the effect, sometimes in combination with an overlaying pattern.

==== Border Color ====
You can set the border color to any of the 8 colors with:

<syntaxhighlight lang="z80">
ld a,0 ; bottom three bits of a contain the color
out (254),a
</syntaxhighlight>

=== Memory Configuration ===
128K separated to 8 pages (16384 bytes size)
Default configuration is:

: page 5: $4000-$7fff
: page 2: $8000-$Bfff
: page 0: $C000-$Ffff

There are two screens - page 7 and page 5.
port $7FFD allow to control memory and screens:
: bits 0-2 - page number mapped to memory at $C0000
: bit 3 - Select page 5(0) or page 7(1) to be displayed.
: bit 4 - ROM Select. 0-128K,1-48K

Example of use
<syntaxhighlight lang="z80">
loop: ei
halt
pg: ld a,$17
ld bc,$7ffd
out (c),a
xor $0A
ld (pg+1),a
... do something with $C000-$DB00
jp loop
</syntaxhighlight>

$17 is use 48K, map page 7
After xor $0A we'll get value $1D(use 48K ROM, display screen at page 7 and map page5 at $C000).This is so-called "double buffering".
See also : https://worldofspectrum.org/faq/reference/128kreference.htm

==== Getting something on screen ====
Now to get something on screen, lets fill our colorram with a simple AND pattern, like so:
<syntaxhighlight lang="z80">
ld de,5800h
ld b,24
yloop:
ld c,32
xloop:
ld a,c
and b
and 7 ; make sure range is 0..7
ld (de),a
inc de
dec c
jr nz,xloop
djnz yloop
</syntaxhighlight>

==== Using a Backbuffer ====
While the above code will run fine, you might want to consider using a backbuffer for more complex stuff. You can then simply write to another adress define by BACKBUFFER (for example A000) and copy the buffer to colorram like so:

<syntaxhighlight lang="z80">
halt ; synchronize
ld hl,BACKBUFFER
ld de,5800h
ld bc,768
ldir
</syntaxhighlight>

Another alternative method is to use the 128's memory paging, which provides a second screen buffer. This buffer is located at a different memeory location, but otherwise it is the same:
<syntaxhighlight lang="z80">
; main loop starts here
ld a,00010111b ; set up memory banks and screen here
mainloop
halt ; sync
xor 00001010b ; flip screens
out ($fd),a
push af

; render code goes here
; screen buffer is location at 0xC000 instead of 0x4000

pop af
jr mainloop
</syntaxhighlight>

==== Overlaying simple graphics ====
If you don't want to use a solid color/tile for.
You could copy a single tile across the screen at startup for some flair.
<syntaxhighlight lang="z80">
ld a,0x55 ; 01010101 pattern
ld bc,0x1800
copyloop:
ld (de),a
inc de
dec c
jr nz,copyloop
djnz copyloop
</syntaxhighlight>

Alternatively you could generate a pattern using logic operations or random noise/data.
==== Useful routines ====

<syntaxhighlight lang="z80">
;calculate address of next line,HL=address
down_hl:
INC h
LD A,h
AND 7
RET NZ
LD A,L
ADD A,#20
LD L,A
RET C
LD A,H
SUB 8
LD H,A
RET
</syntaxhighlight>

<syntaxhighlight lang="z80">
;move up at screen, HL=address
up_hl
LD A,H
DEC H
AND 7
ret nz
LD A,L
SUB 32
LD L,A
ret c
LD A,H
ADD A,8
LD H,A
ret
</syntaxhighlight>

<syntaxhighlight lang="z80">
;write pixel
CALL 8933 ; C=X(0..255),B=Y(0..175),5C7D=COORDS
</syntaxhighlight>

<syntaxhighlight lang="z80">
;Calculate vertical line screen Address, IN : A=Y coordinate, OUT : HL=address
py2saddr:
ld l,a
; ld a,l
and $07
ld h,a
ld a,l
and $c0
rra
inc a
rrca
rrca
or h
ld h,a
ld a,l
add a
add a
and $e0
ld l,a
</syntaxhighlight>

<syntaxhighlight lang="z80">
;Calculate Attribute address, IB: reg D=Y,reg E=X, OUT: HL=address, destroys DE
ld l,d
add hl,hl
add hl,hl
ld h,$11
add hl,hl
add hl,hl
add hl,hl
ld d,0
add hl,de
</syntaxhighlight>

or alter version
<syntaxhighlight lang="z80">
;H=Y coordinate,L=X coordinate
ld a,h
rrca
rrca
rrca
push af
and 3
add a,$58
ld h,a
pop af
and %11100000
add a,l
ld l,a
</syntaxhighlight>

calculate Pixel coordinate
<syntaxhighlight lang="z80">
;IN: A=X coordinate,C=L=Y coordinate
;OUT: HL=screen address,A=bit value
call #22B0
</syntaxhighlight>

=== Sound ===
The original Spectrum has only a 1 bit sound capability (BEEP) through its internal speaker.
Later models included the AY-3-8910 Soundchip which provides 3 channels of PSG sound.

==== Make some noise - Beeper ====
Setting/toggling bit 4 of port 254 will enable the beeper speaker.

<syntaxhighlight lang="z80">
ld a,$10 ;Bit 4 set
beeploop: xor $10 ;toggle Bit 4
out (254),a
ld b,90 ;wait
djnz $
jp beeploop
</syntaxhighlight>
Note that the bottom three bits of port 254 also set the border color (see above).

==== Make some noise - AY ====
You can access the AY soundchip by outputting to the following ports:

<syntaxhighlight lang="z80">
ld bc,0xfffd
ld a, ay register number
out (c),a
ld b,0xbf
ld a, data byte
out (c),a
</syntaxhighlight>

For more information about the soundchip, check out:
https://www.atarimagazines.com/v4n7/stsound.html

=== Small demos with documented source code ===
* Ceci N'est Pas Un Cube by Ate Bit https://www.pouet.net/prod.php?which=29691
* Zxwister by Ate Bit https://www.pouet.net/prod.php?which=44123
* Muse by Ate Bit https://www.pouet.net/prod.php?which=62880
* Starlet Guitarlet by HOOY-PROGRAM https://www.pouet.net/prod.php?which=52553
* Clangers On The Dancefloor by HOOY-PROGRAM https://www.pouet.net/prod.php?which=29696
* Chessington World Of Adventure by HOOY-PROGRAM https://www.pouet.net/prod.php?which=76074
* Roll Me Gently by Joker https://www.pouet.net/prod.php?which=86338

=== Additional Resources ===
I found resources on ZX Spectrum sizecoding to be sparse.
* All kinds of Z80 Information http://www.z80.info/index.htm
* Another source for good Z80 Information http://z80-heaven.wikidot.com
* Assembler subforum on world of spectrum https://worldofspectrum.org/forums/categories/assembler
* Development subforum on Spectrum Computing https://spectrumcomputing.co.uk/forums/viewforum.php?f=6
* Blogpost on ZX Spectrum coding from a X86 coder's perspective on superogue's sizecdoing blog http://marquee.revival-studios.com/blog/blog_fluxus.html
* 128byte/256 byte zx spectrum productions by goblinish https://www.pouet.net/groups.php?which=11696&order=type
* 128byte/256 byte zx spectrum productions by gasman https://www.pouet.net/groups.php?which=1218&order=type
* Easy to read list of all Z80 instructions (including undocumented ones) with size and timing information https://clrhome.org/table/
* Detailed information on the screen layout http://www.overtakenbyevents.com/lets-talk-about-the-zx-specrum-screen-layout/ http://www.overtakenbyevents.com/lets-talk-about-the-zx-specrum-screen-layout-part-two/ and http://www.overtakenbyevents.com/lets-talk-about-the-zx-specrum-screen-layout-part-three/

== Amstrad CPC ==
The Amstrad consists of a Z80A @ 3.5 MHz CPU

=== Setting up ===
Setting up..

* Assembler: -
* Emulator(s): -

=== Video Display ===
No information yet

=== Sound ===
No information yet

=== Additional Resources ===
* 64 NOPs Amstrad CPC Tech Blog - https://64nops.wordpress.com/

Compos

2020-04-09T07:30:28Z

Dresdenboy: Initial Compo page with table template

== Sizecoding Compos at various Demo Parties ==

{| class="wikitable sortable"
|-
! Party !! Date !! Location !! Sizes !! Deadline !! Compo Machine !! Remote Entries !! Rules
|-
| Example || Example || Example || Example || Example || Example || Example || Example
|-
| Example || Example || Example || Example || Example || Example || Example || Example
|-
| Example || Example || Example || Example || Example || Example || Example || Example
|-
| Example || Example || Example || Example || Example || Example || Example || Example
|-
| Example || Example || Example || Example || Example || Example || Example || Example
|}

Resources

2019-11-07T11:35:20Z

Dresdenboy: /* References */

== Discussions ==

Pouet's [http://www.pouet.net/topic.php?which=8791&page=1 Tiny Intro Toolbox Thread] was one of sizecoding.org's main inspirations.

== References ==

The Hugi demoscene diskmag has been kind to the sizecoding movement. They included [http://www.hugi.scene.org/online/coding/hugi%20se%204%20-%20index%20sorted%20by%20topic.htm many programming articles] since it started in 1996. Additionally, the [http://www.hugi.scene.org/compo/compoold.htm Hugi Size Coding Competition Series] is the gold standard for learning how to sizecode: Each competition was given a specific task, then participants submitted their results. ([http://retrolandia.net/hugi/showthread.php?tid=7&pid=13#pid13 All of the entries with their source code] are available, as are [http://retrolandia.net/hugi/showthread.php?tid=7&pid=396#pid396 the rules for each challenge].) Hugi #35 also provided a [http://hugi.scene.org/online/hugi35/hugi%2035%20-%20demoscene%20forum%20adok%20256b%20intros%20round-table.htm 256b intros round-table] between Baze, Digimind, Řrřola, Pirx, Optimus, and Seven.

During the last years 256b intro coding was also a topic in some demo party presentation sessions. The recordings are available on YouTube. There are
[https://www.youtube.com/watch?v=WbWYBE9vjdk part 1] and [https://www.youtube.com/watch?v=51BOp5Pi4mU part 2] of Řrřola's talk "Magic of 256-byte x86 intros" held at Demobit 2017 and 2018 respectively. A similar talk [https://www.youtube.com/watch?v=V_ntnQKemWA "256 byte intros on modern PCs"] was held by TomCat/Abaddon at the Function 2017 party. Supplemental files can be downloaded from [http://www.pouet.net/prod.php?which=72454 Pouet.net]. The presentations cover everything from setting up the coding environment to all kinds of code optimization, constant reuse, flag tricks, palette generation, and how to get from an idea to the final intro. TomCat also provides a [https://www.abaddon.hu/256b/ dev tools page] and his [https://www.abaddon.hu/256b/ SizeCoding Blog] with lots of optimization ideas.

fysnet.net has an extensive [http://www.fysnet.net/yourhelp.htm list of DOS .COM register starting values]. If your environment isn't listed, [http://www.fysnet.net/yourhelp.com a program] is also available that can print out all of the register starting values. See also [http://pferrie.host22.com/misc/lowlevel12.htm DOS Register Starting Values] to understand why the register starting values for .COM files are set the way that they are.

The [http://sparksandflames.com/files/x86InstructionChart.html Sparks And Flames x86 Instruction Chart] is awesome, once you can "read" it. Find out what the bright green (1-byte) commands do, and use them. For the extreme sizecoding (<=32 bytes) it's also very useful to have the HEX value in sight.

The [http://ref.x86asm.net/geek.html Geek Edition x86asm-ref] is comprehensive and dense. It might be the only reference you'll need. The [http://ref.x86asm.net/geek.html#modrm_byte_16 last part] covers modr/m bytes, which is useful.

[http://x86.renejeschke.de/ Rene Jeschke's preservation of siyobik.com's x86 Documentation] is one of the most compact and understandable references to the x86 instruction set you'll ever see.

Intel IA-32 Software Developer's Manual Instruction Set Reference [http://www.jaist.ac.jp/iscenter-new/mpc/altix/altixdata/opt/intel/vtune/doc/users_guide/mergedProjects/analyzer_ec/mergedProjects/reference_olh/mergedProjects/instructions/whgdata/whlstt2.htm hypertext version].

[http://www.rcollins.org/secrets/OpCodes.html Robert Collins' Undocumented Opcodes] page has some gems you can exploit depending on your target environment.

[http://wiki.osdev.org/PC_Speaker PC Speaker Basics] For everything from simple bleeps to sophisticated synthesizers.

[https://en.wikipedia.org/wiki/Program_Segment_Prefix Program Segment Prefix] : what's in front of our .COM code, and why.

Never underestimate [http://www.hugi.scene.org/online/coding/hugi%2017%20-%20coaax.htm The Hidden Power of BCD Instructions].

[http://www.agner.org/optimize/optimizing_assembly.pdf An optimization guide for x86 platforms By Agner Fog] Chapter 10: Optimizing for size.

[http://home.sch.bme.hu/~ervin/codegems.html Code Gems by Ervin/AbaddoN] Nice collection based on the Imphobia diskmagazine article.

[http://wiki.osdev.org/Programmable_Interval_Timer Programmable Interval Timer]: Timing is everything, if you're targeting a slow system. Very old but good text [http://www.phatcode.net/res/246/files/pctim003.txt PCTIM003.TXT]

[http://stanislavs.org/helppc/bios_data_area.html BIOS data area]: Direct system communication overview. There are environment values here you may be able to utilize.

[https://www.midi.org/specifications/item/table-1-summary-of-midi-message Summary of MIDI messages] : Summary of all basic MIDI messages.

[http://www.voidaudio.net/percussion.html Roland GS/GM2 Drum Set List and Note Map] : Detailed Description of all MIDI drumkits.

[http://www.h-schmidt.net/FloatConverter/IEEE754.html Online IEEE 754 Converter] : Excellent tool for optimizing/reusing FPU constants

[https://www.reddit.com/r/tinycode Tinycode on Reddit]: Collection of many different size coding productions incl. x86 based ones with discussion (mostly provided by [https://www.reddit.com/user/Hell__Mood/ HellMood] himself)

== Repositories ==

Tinyprogs are so small that you sometimes don't need the source code to understand them: Just pop them into a disassembler (like IDA) or a debugger and look at them. If you want to grab specimens for study, here are some places to start.

Pouet can be searched for the latest tinyprogs: [http://www.pouet.net/prodlist.php?type%5B%5D=256b&platform%5B%5D=MS-Dos&page=1 256b], [http://www.pouet.net/prodlist.php?type%5B%5D=128b&platform%5B%5D=MS-Dos&page=1 128b], [http://www.pouet.net/prodlist.php?type%5B%5D=64b&platform%5B%5D=MS-Dos&page=1 64b], and even [http://www.pouet.net/prodlist.php?type%5B%5D=32b&platform%5B%5D=MS-Dos&page=1 32b and smaller].

[http://hardcode.untergrund.net/ HardCode] is a repository of 7800 64KB and smaller intros.

[http://256bytes.untergrund.net 256b.com] is a website dedicated primarily to 256b and smaller releases.

Resources

2019-11-07T11:33:50Z

Dresdenboy: /* References */ Added more resources from TomCat and the Tinycode Reddit.

== Discussions ==

Pouet's [http://www.pouet.net/topic.php?which=8791&page=1 Tiny Intro Toolbox Thread] was one of sizecoding.org's main inspirations.

== References ==

The Hugi demoscene diskmag has been kind to the sizecoding movement. They included [http://www.hugi.scene.org/online/coding/hugi%20se%204%20-%20index%20sorted%20by%20topic.htm many programming articles] since it started in 1996. Additionally, the [http://www.hugi.scene.org/compo/compoold.htm Hugi Size Coding Competition Series] is the gold standard for learning how to sizecode: Each competition was given a specific task, then participants submitted their results. ([http://retrolandia.net/hugi/showthread.php?tid=7&pid=13#pid13 All of the entries with their source code] are available, as are [http://retrolandia.net/hugi/showthread.php?tid=7&pid=396#pid396 the rules for each challenge].) Hugi #35 also provided a [http://hugi.scene.org/online/hugi35/hugi%2035%20-%20demoscene%20forum%20adok%20256b%20intros%20round-table.htm 256b intros round-table] between Baze, Digimind, Řrřola, Pirx, Optimus, and Seven.

During the last years 256b intro coding was also a topic in some demo party presentation sessions. The recordings are available on YouTube. There are
[https://www.youtube.com/watch?v=WbWYBE9vjdk part 1] and [https://www.youtube.com/watch?v=51BOp5Pi4mU part 2] of Řrřola's talk "Magic of 256-byte x86 intros" held at Demobit 2017 and 2018 respectively. A similar talk [https://www.youtube.com/watch?v=V_ntnQKemWA "256 byte intros on modern PCs"] was held by TomCat/Abaddon at the Function 2017 party. Supplemental files can be downloaded from [http://www.pouet.net/prod.php?which=72454 Pouet.net]. The presentations cover everything from setting up the coding environment to all kinds of code optimization, constant reuse, flag tricks, palette generation, and how to get from an idea to the final intro. TomCat also provides a [https://www.abaddon.hu/256b/ dev tools page] and his [https://www.abaddon.hu/256b/ SizeCoding Blog] with lots of optimization ideas.

fysnet.net has an extensive [http://www.fysnet.net/yourhelp.htm list of DOS .COM register starting values]. If your environment isn't listed, [http://www.fysnet.net/yourhelp.com a program] is also available that can print out all of the register starting values. See also [http://pferrie.host22.com/misc/lowlevel12.htm DOS Register Starting Values] to understand why the register starting values for .COM files are set the way that they are.

The [http://sparksandflames.com/files/x86InstructionChart.html Sparks And Flames x86 Instruction Chart] is awesome, once you can "read" it. Find out what the bright green (1-byte) commands do, and use them. For the extreme sizecoding (<=32 bytes) it's also very useful to have the HEX value in sight.

The [http://ref.x86asm.net/geek.html Geek Edition x86asm-ref] is comprehensive and dense. It might be the only reference you'll need. The [http://ref.x86asm.net/geek.html#modrm_byte_16 last part] covers modr/m bytes, which is useful.

[http://x86.renejeschke.de/ Rene Jeschke's preservation of siyobik.com's x86 Documentation] is one of the most compact and understandable references to the x86 instruction set you'll ever see.

Intel IA-32 Software Developer's Manual Instruction Set Reference [http://www.jaist.ac.jp/iscenter-new/mpc/altix/altixdata/opt/intel/vtune/doc/users_guide/mergedProjects/analyzer_ec/mergedProjects/reference_olh/mergedProjects/instructions/whgdata/whlstt2.htm hypertext version].

[http://www.rcollins.org/secrets/OpCodes.html Robert Collins' Undocumented Opcodes] page has some gems you can exploit depending on your target environment.

[http://wiki.osdev.org/PC_Speaker PC Speaker Basics] For everything from simple bleeps to sophisticated synthesizers.

[https://en.wikipedia.org/wiki/Program_Segment_Prefix Program Segment Prefix] : what's in front of our .COM code, and why.

Never underestimate [http://www.hugi.scene.org/online/coding/hugi%2017%20-%20coaax.htm The Hidden Power of BCD Instructions].

[http://www.agner.org/optimize/optimizing_assembly.pdf An optimization guide for x86 platforms By Agner Fog] Chapter 10: Optimizing for size.

[http://home.sch.bme.hu/~ervin/codegems.html Code Gems by Ervin/AbaddoN] Nice collection based on the Imphobia diskmagazine article.

[http://wiki.osdev.org/Programmable_Interval_Timer Programmable Interval Timer]: Timing is everything, if you're targeting a slow system. Very old but good text [http://www.phatcode.net/res/246/files/pctim003.txt PCTIM003.TXT]

[http://stanislavs.org/helppc/bios_data_area.html BIOS data area]: Direct system communication overview. There are environment values here you may be able to utilize.

[https://www.midi.org/specifications/item/table-1-summary-of-midi-message Summary of MIDI messages] : Summary of all basic MIDI messages.

[http://www.voidaudio.net/percussion.html Roland GS/GM2 Drum Set List and Note Map] : Detailed Description of all MIDI drumkits.

[http://www.h-schmidt.net/FloatConverter/IEEE754.html Online IEEE 754 Converter] : Excellent tool for optimizing/reusing FPU constants

[https://www.reddit.com/r/tinycode Tinycode on Reddit]: Collection of many different size coding productions incl. x86 based ones with discussion (mostly provided by [https://www.reddit.com/user/Hell__Mood/ Hell_Mood himself])

== Repositories ==

Tinyprogs are so small that you sometimes don't need the source code to understand them: Just pop them into a disassembler (like IDA) or a debugger and look at them. If you want to grab specimens for study, here are some places to start.

Pouet can be searched for the latest tinyprogs: [http://www.pouet.net/prodlist.php?type%5B%5D=256b&platform%5B%5D=MS-Dos&page=1 256b], [http://www.pouet.net/prodlist.php?type%5B%5D=128b&platform%5B%5D=MS-Dos&page=1 128b], [http://www.pouet.net/prodlist.php?type%5B%5D=64b&platform%5B%5D=MS-Dos&page=1 64b], and even [http://www.pouet.net/prodlist.php?type%5B%5D=32b&platform%5B%5D=MS-Dos&page=1 32b and smaller].

[http://hardcode.untergrund.net/ HardCode] is a repository of 7800 64KB and smaller intros.

[http://256bytes.untergrund.net 256b.com] is a website dedicated primarily to 256b and smaller releases.

Resources

2019-04-26T08:21:27Z

Dresdenboy: Added a Linux sizecoding seminar held at Revision 2019

== Discussions ==

Pouet's [http://www.pouet.net/topic.php?which=8791&page=1 Tiny Intro Toolbox Thread] was one of sizecoding.org's main inspirations.

== References ==

The Hugi demoscene diskmag has been kind to the sizecoding movement. They included [http://www.hugi.scene.org/online/coding/hugi%20se%204%20-%20index%20sorted%20by%20topic.htm many programming articles] since it started in 1996. Additionally, the [http://www.hugi.scene.org/compo/compoold.htm Hugi Size Coding Competition Series] is the gold standard for learning how to sizecode: Each competition was given a specific task, then participants submitted their results. ([http://retrolandia.net/hugi/showthread.php?tid=7&pid=13#pid13 All of the entries with their source code] are available, as are [http://retrolandia.net/hugi/showthread.php?tid=7&pid=396#pid396 the rules for each challenge].) Hugi #35 also provided a [http://hugi.scene.org/online/hugi35/hugi%2035%20-%20demoscene%20forum%20adok%20256b%20intros%20round-table.htm 256b intros round-table] between Baze, Digimind, Řrřola, Pirx, Optimus, and Seven.

During the last years 256b intro coding was also a topic in some demo party presentation sessions. The recordings are available on YouTube. There are
[https://www.youtube.com/watch?v=WbWYBE9vjdk part 1] and [https://www.youtube.com/watch?v=51BOp5Pi4mU part 2] of Řrřola's talk "Magic of 256-byte x86 intros" held at Demobit 2017 and 2018 respectively. A similar talk [https://www.youtube.com/watch?v=V_ntnQKemWA "256 byte intros on modern PCs"] was held by TomCat/Abaddon at the Function 2017 party. Supplemental files can be downloaded from [http://www.pouet.net/prod.php?which=72454 Pouet.net]. The presentations cover everything from setting up the coding environment to all kinds of code optimization, constant reuse, flag tricks, palette generation, and how to get from an idea to the final intro.

fysnet.net has an extensive [http://www.fysnet.net/yourhelp.htm list of DOS .COM register starting values]. If your environment isn't listed, [http://www.fysnet.net/yourhelp.com a program] is also available that can print out all of the register starting values. See also [http://pferrie.host22.com/misc/lowlevel12.htm DOS Register Starting Values] to understand why the register starting values for .COM files are set the way that they are.

The [http://sparksandflames.com/files/x86InstructionChart.html Sparks And Flames x86 Instruction Chart] is awesome, once you can "read" it. Find out what the bright green (1-byte) commands do, and use them. For the extreme sizecoding (<=32 bytes) it's also very useful to have the HEX value in sight.

The [http://ref.x86asm.net/geek.html Geek Edition x86asm-ref] is comprehensive and dense. It might be the only reference you'll need. The [http://ref.x86asm.net/geek.html#modrm_byte_16 last part] covers modr/m bytes, which is useful.

[http://x86.renejeschke.de/ Rene Jeschke's preservation of siyobik.com's x86 Documentation] is one of the most compact and understandable references to the x86 instruction set you'll ever see.

Intel IA-32 Software Developer's Manual Instruction Set Reference [http://www.jaist.ac.jp/iscenter-new/mpc/altix/altixdata/opt/intel/vtune/doc/users_guide/mergedProjects/analyzer_ec/mergedProjects/reference_olh/mergedProjects/instructions/whgdata/whlstt2.htm hypertext version].

[http://www.rcollins.org/secrets/OpCodes.html Robert Collins' Undocumented Opcodes] page has some gems you can exploit depending on your target environment.

[http://wiki.osdev.org/PC_Speaker PC Speaker Basics] For everything from simple bleeps to sophisticated synthesizers.

[https://en.wikipedia.org/wiki/Program_Segment_Prefix Program Segment Prefix] : what's in front of our .COM code, and why.

Never underestimate [http://www.hugi.scene.org/online/coding/hugi%2017%20-%20coaax.htm The Hidden Power of BCD Instructions].

[http://www.agner.org/optimize/optimizing_assembly.pdf An optimization guide for x86 platforms By Agner Fog] Chapter 10: Optimizing for size.

[http://home.sch.bme.hu/~ervin/codegems.html Code Gems by Ervin/AbaddoN] Nice collection based on the Imphobia diskmagazine article.

[http://wiki.osdev.org/Programmable_Interval_Timer Programmable Interval Timer]: Timing is everything, if you're targeting a slow system. Very old but good text [http://www.phatcode.net/res/246/files/pctim003.txt PCTIM003.TXT]

[http://stanislavs.org/helppc/bios_data_area.html BIOS data area]: Direct system communication overview. There are environment values here you may be able to utilize.

[https://www.midi.org/specifications/item/table-1-summary-of-midi-message Summary of MIDI messages] : Summary of all basic MIDI messages.

[http://www.voidaudio.net/percussion.html Roland GS/GM2 Drum Set List and Note Map] : Detailed Description of all MIDI drumkits.

[http://www.h-schmidt.net/FloatConverter/IEEE754.html Online IEEE 754 Converter] : Excellent tool for optimizing/reusing FPU constants

[https://www.youtube.com/watch?v=a03HXo8a_Io Intricacies of sizecoding on Linux] : A Revision 2019 Seminar about sizecoding on Linux

== Repositories ==

Tinyprogs are so small that you sometimes don't need the source code to understand them: Just pop them into a disassembler (like IDA) or a debugger and look at them. If you want to grab specimens for study, here are some places to start.

Pouet can be searched for the latest tinyprogs: [http://www.pouet.net/prodlist.php?type%5B%5D=256b&platform%5B%5D=MS-Dos&page=1 256b], [http://www.pouet.net/prodlist.php?type%5B%5D=128b&platform%5B%5D=MS-Dos&page=1 128b], [http://www.pouet.net/prodlist.php?type%5B%5D=64b&platform%5B%5D=MS-Dos&page=1 64b], and even [http://www.pouet.net/prodlist.php?type%5B%5D=32b&platform%5B%5D=MS-Dos&page=1 32b and smaller].

[http://hardcode.untergrund.net/ HardCode] is a repository of 7800 64KB and smaller intros.

[http://256bytes.untergrund.net 256b.com] is a website dedicated primarily to 256b and smaller releases.

Resources

2018-04-17T14:04:12Z

Dresdenboy: /* References */ Added a download link and did minor text edits.

== Discussions ==

Pouet's [http://www.pouet.net/topic.php?which=8791&page=1 Tiny Intro Toolbox Thread] was one of sizecoding.org's main inspirations.

== References ==

The Hugi demoscene diskmag has been kind to the sizecoding movement. They included [http://www.hugi.scene.org/online/coding/hugi%20se%204%20-%20index%20sorted%20by%20topic.htm many programming articles] since it started in 1996. Additionally, the [http://www.hugi.scene.org/compo/compoold.htm Hugi Size Coding Competition Series] is the gold standard for learning how to sizecode: Each competition was given a specific task, then participants submitted their results. ([http://retrolandia.net/hugi/showthread.php?tid=7&pid=13#pid13 All of the entries with their source code] are available, as are [http://retrolandia.net/hugi/showthread.php?tid=7&pid=396#pid396 the rules for each challenge].) Hugi #35 also provided a [http://hugi.scene.org/online/hugi35/hugi%2035%20-%20demoscene%20forum%20adok%20256b%20intros%20round-table.htm 256b intros round-table] between Baze, Digimind, Řrřola, Pirx, Optimus, and Seven.

During the last years 256b intro coding was also a topic in some demo party presentation sessions. The recordings are available on YouTube. There are
[https://www.youtube.com/watch?v=WbWYBE9vjdk part 1] and [https://www.youtube.com/watch?v=51BOp5Pi4mU part 2] of Řrřola's talk "Magic of 256-byte x86 intros" held at Demobit 2017 and 2018 respectively. A similar talk [https://www.youtube.com/watch?v=V_ntnQKemWA "256 byte intros on modern PCs"] was held by TomCat/Abaddon at the Function 2017 party. Supplemental files can be downloaded from [http://www.pouet.net/prod.php?which=72454 Pouet.net]. The presentations cover everything from setting up the coding environment to all kinds of code optimization, constant reuse, flag tricks, palette generation, and how to get from an idea to the final intro.

fysnet.net has an extensive [http://www.fysnet.net/yourhelp.htm list of DOS .COM register starting values]. If your environment isn't listed, [http://www.fysnet.net/yourhelp.com a program] is also available that can print out all of the register starting values. See also [http://pferrie.host22.com/misc/lowlevel12.htm DOS Register Starting Values] to understand why the register starting values for .COM files are set the way that they are.

The [http://sparksandflames.com/files/x86InstructionChart.html Sparks And Flames x86 Instruction Chart] is awesome, once you can "read" it. Find out what the bright green (1-byte) commands do, and use them. For the extreme sizecoding (<=32 bytes) it's also very useful to have the HEX value in sight.

The [http://ref.x86asm.net/geek.html Geek Edition x86asm-ref] is comprehensive and dense. It might be the only reference you'll need. The [http://ref.x86asm.net/geek.html#modrm_byte_16 last part] covers modr/m bytes, which is useful.

[http://x86.renejeschke.de/ Rene Jeschke's preservation of siyobik.com's x86 Documentation] is one of the most compact and understandable references to the x86 instruction set you'll ever see.

Intel IA-32 Software Developer's Manual Instruction Set Reference [http://www.jaist.ac.jp/iscenter-new/mpc/altix/altixdata/opt/intel/vtune/doc/users_guide/mergedProjects/analyzer_ec/mergedProjects/reference_olh/mergedProjects/instructions/whgdata/whlstt2.htm hypertext version].

[http://www.rcollins.org/secrets/OpCodes.html Robert Collins' Undocumented Opcodes] page has some gems you can exploit depending on your target environment.

[http://wiki.osdev.org/PC_Speaker PC Speaker Basics] For everything from simple bleeps to sophisticated synthesizers.

[https://en.wikipedia.org/wiki/Program_Segment_Prefix Program Segment Prefix] : what's in front of our .COM code, and why.

Never underestimate [http://www.hugi.scene.org/online/coding/hugi%2017%20-%20coaax.htm The Hidden Power of BCD Instructions].

[http://www.agner.org/optimize/optimizing_assembly.pdf An optimization guide for x86 platforms By Agner Fog] Chapter 10: Optimizing for size.

[http://home.sch.bme.hu/~ervin/codegems.html Code Gems by Ervin/AbaddoN] Nice collection based on the Imphobia diskmagazine article.

[http://wiki.osdev.org/Programmable_Interval_Timer Programmable Interval Timer]: Timing is everything, if you're targeting a slow system. Very old but good text [http://www.phatcode.net/res/246/files/pctim003.txt PCTIM003.TXT]

[http://stanislavs.org/helppc/bios_data_area.html BIOS data area]: Direct system communication overview. There are environment values here you may be able to utilize.

[https://www.midi.org/specifications/item/table-1-summary-of-midi-message Summary of MIDI messages] : Summary of all basic MIDI messages.

[http://www.voidaudio.net/percussion.html Roland GS/GM2 Drum Set List and Note Map] : Detailed Description of all MIDI drumkits.

[http://www.h-schmidt.net/FloatConverter/IEEE754.html Online IEEE 754 Converter] Excellent tool for optimizing/reusing FPU constants

== Repositories ==

Tinyprogs are so small that you sometimes don't need the source code to understand them: Just pop them into a disassembler (like IDA) or a debugger and look at them. If you want to grab specimens for study, here are some places to start.

Pouet can be searched for the latest tinyprogs: [http://www.pouet.net/prodlist.php?type%5B%5D=256b&platform%5B%5D=MS-Dos&page=1 256b], [http://www.pouet.net/prodlist.php?type%5B%5D=128b&platform%5B%5D=MS-Dos&page=1 128b], [http://www.pouet.net/prodlist.php?type%5B%5D=64b&platform%5B%5D=MS-Dos&page=1 64b], and even [http://www.pouet.net/prodlist.php?type%5B%5D=32b&platform%5B%5D=MS-Dos&page=1 32b and smaller].

[http://hardcode.untergrund.net/ HardCode] is a repository of 7800 64KB and smaller intros.

[http://256bytes.untergrund.net 256b.com] is a website dedicated primarily to 256b and smaller releases.

Resources

2018-04-17T08:12:35Z

Dresdenboy: Added 256b intro coding talks by Řrřola and TomCat

== Discussions ==

Pouet's [http://www.pouet.net/topic.php?which=8791&page=1 Tiny Intro Toolbox Thread] was one of sizecoding.org's main inspirations.

== References ==

The Hugi demoscene diskmag has been kind to the sizecoding movement. They included [http://www.hugi.scene.org/online/coding/hugi%20se%204%20-%20index%20sorted%20by%20topic.htm many programming articles] since it started in 1996. Additionally, the [http://www.hugi.scene.org/compo/compoold.htm Hugi Size Coding Competition Series] is the gold standard for learning how to sizecode: Each competition was given a specific task, then participants submitted their results. ([http://retrolandia.net/hugi/showthread.php?tid=7&pid=13#pid13 All of the entries with their source code] are available, as are [http://retrolandia.net/hugi/showthread.php?tid=7&pid=396#pid396 the rules for each challenge].) Hugi #35 also provided a [http://hugi.scene.org/online/hugi35/hugi%2035%20-%20demoscene%20forum%20adok%20256b%20intros%20round-table.htm 256b intros round-table] between Baze, Digimind, Řrřola, Pirx, Optimus, and Seven.

During the last years 256b intro coding was also a topic in some demo party presentation sessions. The recordings are available on YouTube. There are
[https://www.youtube.com/watch?v=WbWYBE9vjdk part 1] and [https://www.youtube.com/watch?v=51BOp5Pi4mU part 2] of Řrřola's talk "Magic of 256-byte x86 intros" held at Demobit 2017 and 2018 respectively. A similar talk [https://www.youtube.com/watch?v=V_ntnQKemWA "256 byte intros on modern PCs"] was held by TomCat/Abaddon at the Function 2017 party (mostly in English with parts spoken in Hungarian). Those presentations cover everything from setting up the coding environment to all kinds of code optimization, constant reuse, flag tricks, palette generation, and how to get from an idea to the final intro.

fysnet.net has an extensive [http://www.fysnet.net/yourhelp.htm list of DOS .COM register starting values]. If your environment isn't listed, [http://www.fysnet.net/yourhelp.com a program] is also available that can print out all of the register starting values. See also [http://pferrie.host22.com/misc/lowlevel12.htm DOS Register Starting Values] to understand why the register starting values for .COM files are set the way that they are.

The [http://sparksandflames.com/files/x86InstructionChart.html Sparks And Flames x86 Instruction Chart] is awesome, once you can "read" it. Find out what the bright green (1-byte) commands do, and use them. For the extreme sizecoding (<=32 bytes) it's also very useful to have the HEX value in sight.

The [http://ref.x86asm.net/geek.html Geek Edition x86asm-ref] is comprehensive and dense. It might be the only reference you'll need. The [http://ref.x86asm.net/geek.html#modrm_byte_16 last part] covers modr/m bytes, which is useful.

[http://x86.renejeschke.de/ Rene Jeschke's preservation of siyobik.com's x86 Documentation] is one of the most compact and understandable references to the x86 instruction set you'll ever see.

Intel IA-32 Software Developer's Manual Instruction Set Reference [http://www.jaist.ac.jp/iscenter-new/mpc/altix/altixdata/opt/intel/vtune/doc/users_guide/mergedProjects/analyzer_ec/mergedProjects/reference_olh/mergedProjects/instructions/whgdata/whlstt2.htm hypertext version].

[http://www.rcollins.org/secrets/OpCodes.html Robert Collins' Undocumented Opcodes] page has some gems you can exploit depending on your target environment.

[http://wiki.osdev.org/PC_Speaker PC Speaker Basics] For everything from simple bleeps to sophisticated synthesizers.

[https://en.wikipedia.org/wiki/Program_Segment_Prefix Program Segment Prefix] : what's in front of our .COM code, and why.

Never underestimate [http://www.hugi.scene.org/online/coding/hugi%2017%20-%20coaax.htm The Hidden Power of BCD Instructions].

[http://www.agner.org/optimize/optimizing_assembly.pdf An optimization guide for x86 platforms By Agner Fog] Chapter 10: Optimizing for size.

[http://home.sch.bme.hu/~ervin/codegems.html Code Gems by Ervin/AbaddoN] Nice collection based on the Imphobia diskmagazine article.

[http://wiki.osdev.org/Programmable_Interval_Timer Programmable Interval Timer]: Timing is everything, if you're targeting a slow system. Very old but good text [http://www.phatcode.net/res/246/files/pctim003.txt PCTIM003.TXT]

[http://stanislavs.org/helppc/bios_data_area.html BIOS data area]: Direct system communication overview. There are environment values here you may be able to utilize.

[https://www.midi.org/specifications/item/table-1-summary-of-midi-message Summary of MIDI messages] : Summary of all basic MIDI messages.

[http://www.voidaudio.net/percussion.html Roland GS/GM2 Drum Set List and Note Map] : Detailed Description of all MIDI drumkits.

[http://www.h-schmidt.net/FloatConverter/IEEE754.html Online IEEE 754 Converter] Excellent tool for optimizing/reusing FPU constants

== Repositories ==

Tinyprogs are so small that you sometimes don't need the source code to understand them: Just pop them into a disassembler (like IDA) or a debugger and look at them. If you want to grab specimens for study, here are some places to start.

Pouet can be searched for the latest tinyprogs: [http://www.pouet.net/prodlist.php?type%5B%5D=256b&platform%5B%5D=MS-Dos&page=1 256b], [http://www.pouet.net/prodlist.php?type%5B%5D=128b&platform%5B%5D=MS-Dos&page=1 128b], [http://www.pouet.net/prodlist.php?type%5B%5D=64b&platform%5B%5D=MS-Dos&page=1 64b], and even [http://www.pouet.net/prodlist.php?type%5B%5D=32b&platform%5B%5D=MS-Dos&page=1 32b and smaller].

[http://hardcode.untergrund.net/ HardCode] is a repository of 7800 64KB and smaller intros.

[http://256bytes.untergrund.net 256b.com] is a website dedicated primarily to 256b and smaller releases.