Foenix F256 / Wildbits/K2 Wiki - User contributions [en]

C Development

2026-03-21T16:31:18Z

1BitFeverDreams: /* Getting set up on Windows 10/11 (-Mu0n) */ better compilation line at the very end

== '''C Compilers''' ==
* [[cc65]]
* [https://www.calypsi.cc/ Calypsi]
* [[llvm-mos]]
* oscar64

=== LLVM-MOS ===
This fork of llvm-mos was adapted for F256/Wildbits usage by user sduensing from Kangaroo Punch Studios and [https://kangaroopunch.com/view/ShowSoftware?id=13 can be found here]. The installation instructions are simple and work for both Windows and Linux. It mostly uses a one-stop-shop f256lib.h file containing macros and functions leveraging some devices (not all yet) and the MicroKernel.

The default linking configuration will have your code start at 0x300, a 8 kb stack/trampoline from 0xA000 to 0xBFFF that is used to bring in higher memory content visible into that slice of the first 64k of the CPU. The slice 0xC000 to 0xDFFF is used by IO as usual and 0xE000 to 0xFFFF is used by the MicroKernel as usual. To change any of this, you can bring a modified copy of link.ld into your /projectfolder/ and it will supersede this default mapping.<blockquote>
==== List of "Gotchas" for llvm-mos ====
1) When trying to use the EMBED directive in order to put data at specific memory locations, keep in mind that you CAN'T comment those lines out with <code>/*</code> and <code>*/</code>, the compiler will try to follow them whether they're in them or not. The only way to comment them is to use <code>//</code>.

2) When trying to use the EMBED directive, you may want to put your assets in a subfolder of your project. As in, assuming your source files are in ./src/ (where '.' is the root of your project) and your assets are in ./assets/, then you WILL need to refer to your asset files like so: <code>EMBED(myassetname, "../assets/myassetfile.bin", 0x10000);</code>. Note the weird ../ folder backtracking that has to be used. No other combination worked for me (-Mu0n)

3) In the f256dev/ folder, the f256build.bat file contains all you need to compile and link your project. In the "call mos-f256-clang.bat" line, one important switch is the optimization level you let the compiler use. Experiment with -O1 (no optimization), -O2 (some) and -O3 (most). Some operations and repetitions work with some and fail with others. One prominent example of where it failed was a repetitive fileRead operation that read and parsed little chunks of data from a file, byte by byte and while it compiled and linked, it failed during execution. By reducing -O3 to -O2, it all worked again.

4) One linking error kept giving me "<code>ld.lld: error: ld-temp.o <inline asm>:2:1: operand must be a 16-bit address sta (mos8(.LpickAudioFile_zp_stk+4)</code>" despite not having written any inline assembly in my project. You can skirt around the issue for the problematic function by adding a compiler attribute: <code>__attribute__((optnone))</code> right before your function definition.

5) When your code nears a size of 0x9400 and above, you may get in trouble in terms of code not being fully loaded into RAM while executing. Either deliberately put some code into far memory and devise a scheme with the MMU to swap that code in and out of reach for the CPU, or you can carve yourself a bit more space by editing f256dev/llvm-mos/mos-platform/f256/lib/link.ld and change:

<code>/* fake C Stack */</code>

<code>PROVIDE(__stack = 0xA000);</code>

<code>to</code>

<code>/* fake C Stack */</code>

<code>PROVIDE(__stack = 0xC000);</code>

to get yourself an extra 8k of code space before it collides with the stack

6) The compiler will often complain about a missing closing curly bracket '}' at the end of your source files. Just add the one it requires at the very end even though it's an extra one, or, finish your source file by putting your last function with this notation:

<code>void myLastFunction(uint8_t whatever) {</code>

<code>//bunchacode</code>

<code>}</code></blockquote><blockquote>
==== jbaker8935's guide on creating trampolines for functions in higher memory: ====

what you can do is pick a function in one of your projects that isnt time critical and create a trampoline function for it using this pattern:

void FAR8_video_init(void);

<pre>
#pragma clang optimize off
__attribute__((noinline))
void video_init(void) {
volatile unsigned char ___mmu = (unsigned char)*(volatile unsigned char *)0x000d;
*(volatile unsigned char *)0x000d = 8;
FAR8_video_init();
*(volatile unsigned char *)0x000d = ___mmu;
}
#pragma clang optimize on

__attribute__((noinline, section(".block8")))
void FAR8_video_init(void)
</pre>

note: that FAR8_video_init is the renamed function that is being moved. It's just a convention.
in your main you can call video_init as you do normally and the trampoline will take care of swapping the code into A000 in cpu memory.
For linking you need to create file f256.ld that sits in the project directory. it is a copy of "${ROOT}/llvm-mos/mos-platform/f256/lib/link.ld" but has additional linker instructions to explain how to deal with block8. à
Around line 100 or so you need to add instructions after the include output.ld statement. like so:

<pre>
/* Overlay Segments and Binary Data */
INCLUDE output.ld

/* Hand Coded output.ld records */
SHORT(8*0x2000)
BYTE(8/8)
SHORT(end_block8 - __block8_lma)
BYTE(0x00)
TRIM(block8)
</pre>

i'm using f256build.sh and the normal 'everything in src' structure. Also I didnt fiddle with moving the default stack or swap page, so this example trampoline is using A000 (writing to 0x000d). Note that the mmu is left in edit mode, so the trampolines can just write to 000d with no disabling of interrupts.</blockquote>

=== Oscar64 ===
<blockquote>Oscar64 is a C/C++ cross compiler running on a modern system (such as a Windows PC, Mac or Linux machine) and targets the classic 6502 family of processors. It is mainly focused on Commodore systems such as the C64, PET or VIC20. The compiler supports C99 and many C++ features up to variadic templates and lambda functions.

The purpose of this compiler is to eliminate the need to write 6502 assembler code to achieve high code density and fast execution speed. It continues to improve with all the games, demos and tools written by it. It supports disk overlays and banked cartridges for larger projects.

Oscar64 was adapted for the F256/WildBits by swdfrost and [https://github.com/sdwfrost/oscar64 here is a link its github page]. You will also need the adaptation of the f256lib (ported over from llvm-mos) [https://github.com/sdwfrost/f256lib-oscar64 from this github page] as well, which also includes many projects examples as well. </blockquote>

==== Getting set up on Windows 10/11 (-Mu0n) ====
<blockquote>Assumptions:

* Windows' WSL is installed (ie with Ubuntu)
* Python is installed inside windows
* make is installed inside WSL
* gcc is installed inside WSL ('''sudo apt install build-essential''')
</blockquote>
Step 1) in Windows, make a base directory (let's call it '''BASEPATH''') that will hold both:

* the oscar64 project, but with the 'f256k-support' branch rather than 'main' branch <nowiki>https://github.com/sdwfrost/oscar64</nowiki>

* the f256lib-oscar64 project, 'main branch' <nowiki>https://github.com/sdwfrost/f256lib-oscar64</nowiki>

(both from sdwfrost's GitHub account)

Step 2) from windows, open a cmd window, go to your intended base folder

Step 3) type WSL

Step 4) clone oscar64 with

'''git clone -b f256k-support <nowiki>https://github.com/sdwfrost/oscar64.git</nowiki>'''

Step 5) clone f256lib-oscar64 side by side in the same base folder.

'''git clone -b main <nowiki>https://github.com/sdwfrost/f256lib-oscar64</nowiki>'''

Both ''''oscar64'''<nowiki/>' and ''''f256lib-oscar64'''<nowiki/>' folders will be in the same location when this is done.

Step 6) go into oscar64/

Step 7) type:

'''make -f make/makefile'''

(this assumes gcc being present in WSL, it will take a while!)

Step 8) switch over to f256lib-oscar64/ and type:

'''OSCAR64=../../oscar64/bin/oscar64 make all'''

(warning 1: at the time of writing this guide, the 2nd project, BachHero, triggers an error that halts the whole list. Simply remove that entry from /f256lib-oscar64/doodles/MakeFile to get the rest going) (warning 2: most projects will compile, but not run properly when run in the Wildbits environment since they expect extra library files that have not been ported over)

Step 9) to compile a single project in general, make sure you use a path that points to the compiled oscar64 of step 7 like so: (assuming your project myproject is in BASEPATH/f256lib-oscar64/doodles/)

'''BASEPATH/oscar64/bin/oscar64 -tm=f256k -n -i=BASEPATH/f256lib-oscar64/f256lib BASEPATH/f256lib-oscar64/doodles/myproject/src/myproject.c -o=BASEPATH/f256lib-oscar64/doodles/myproject/myproject.pgz'''

C Development

2026-03-21T14:41:28Z

1BitFeverDreams: /* Getting set up on Windows 10/11 (-Mu0n) */

C Development

2026-03-21T14:40:19Z

1BitFeverDreams: /* Getting set up on Windows 10/11 (-Mu0n) */

== '''C Compilers''' ==
* [[cc65]]
* [https://www.calypsi.cc/ Calypsi]
* [[llvm-mos]]
* oscar64

=== LLVM-MOS ===
This fork of llvm-mos was adapted for F256/Wildbits usage by user sduensing from Kangaroo Punch Studios and [https://kangaroopunch.com/view/ShowSoftware?id=13 can be found here]. The installation instructions are simple and work for both Windows and Linux. It mostly uses a one-stop-shop f256lib.h file containing macros and functions leveraging some devices (not all yet) and the MicroKernel.

The default linking configuration will have your code start at 0x300, a 8 kb stack/trampoline from 0xA000 to 0xBFFF that is used to bring in higher memory content visible into that slice of the first 64k of the CPU. The slice 0xC000 to 0xDFFF is used by IO as usual and 0xE000 to 0xFFFF is used by the MicroKernel as usual. To change any of this, you can bring a modified copy of link.ld into your /projectfolder/ and it will supersede this default mapping.<blockquote>
==== List of "Gotchas" for llvm-mos ====
1) When trying to use the EMBED directive in order to put data at specific memory locations, keep in mind that you CAN'T comment those lines out with <code>/*</code> and <code>*/</code>, the compiler will try to follow them whether they're in them or not. The only way to comment them is to use <code>//</code>.

2) When trying to use the EMBED directive, you may want to put your assets in a subfolder of your project. As in, assuming your source files are in ./src/ (where '.' is the root of your project) and your assets are in ./assets/, then you WILL need to refer to your asset files like so: <code>EMBED(myassetname, "../assets/myassetfile.bin", 0x10000);</code>. Note the weird ../ folder backtracking that has to be used. No other combination worked for me (-Mu0n)

3) In the f256dev/ folder, the f256build.bat file contains all you need to compile and link your project. In the "call mos-f256-clang.bat" line, one important switch is the optimization level you let the compiler use. Experiment with -O1 (no optimization), -O2 (some) and -O3 (most). Some operations and repetitions work with some and fail with others. One prominent example of where it failed was a repetitive fileRead operation that read and parsed little chunks of data from a file, byte by byte and while it compiled and linked, it failed during execution. By reducing -O3 to -O2, it all worked again.

4) One linking error kept giving me "<code>ld.lld: error: ld-temp.o <inline asm>:2:1: operand must be a 16-bit address sta (mos8(.LpickAudioFile_zp_stk+4)</code>" despite not having written any inline assembly in my project. You can skirt around the issue for the problematic function by adding a compiler attribute: <code>__attribute__((optnone))</code> right before your function definition.

5) When your code nears a size of 0x9400 and above, you may get in trouble in terms of code not being fully loaded into RAM while executing. Either deliberately put some code into far memory and devise a scheme with the MMU to swap that code in and out of reach for the CPU, or you can carve yourself a bit more space by editing f256dev/llvm-mos/mos-platform/f256/lib/link.ld and change:

<code>/* fake C Stack */</code>

<code>PROVIDE(__stack = 0xA000);</code>

<code>to</code>

<code>/* fake C Stack */</code>

<code>PROVIDE(__stack = 0xC000);</code>

to get yourself an extra 8k of code space before it collides with the stack

6) The compiler will often complain about a missing closing curly bracket '}' at the end of your source files. Just add the one it requires at the very end even though it's an extra one, or, finish your source file by putting your last function with this notation:

<code>void myLastFunction(uint8_t whatever) {</code>

<code>//bunchacode</code>

<code>}</code></blockquote><blockquote>
==== jbaker8935's guide on creating trampolines for functions in higher memory: ====

what you can do is pick a function in one of your projects that isnt time critical and create a trampoline function for it using this pattern:

void FAR8_video_init(void);

<pre>
#pragma clang optimize off
__attribute__((noinline))
void video_init(void) {
volatile unsigned char ___mmu = (unsigned char)*(volatile unsigned char *)0x000d;
*(volatile unsigned char *)0x000d = 8;
FAR8_video_init();
*(volatile unsigned char *)0x000d = ___mmu;
}
#pragma clang optimize on

__attribute__((noinline, section(".block8")))
void FAR8_video_init(void)
</pre>

note: that FAR8_video_init is the renamed function that is being moved. It's just a convention.
in your main you can call video_init as you do normally and the trampoline will take care of swapping the code into A000 in cpu memory.
For linking you need to create file f256.ld that sits in the project directory. it is a copy of "${ROOT}/llvm-mos/mos-platform/f256/lib/link.ld" but has additional linker instructions to explain how to deal with block8. à
Around line 100 or so you need to add instructions after the include output.ld statement. like so:

<pre>
/* Overlay Segments and Binary Data */
INCLUDE output.ld

/* Hand Coded output.ld records */
SHORT(8*0x2000)
BYTE(8/8)
SHORT(end_block8 - __block8_lma)
BYTE(0x00)
TRIM(block8)
</pre>

i'm using f256build.sh and the normal 'everything in src' structure. Also I didnt fiddle with moving the default stack or swap page, so this example trampoline is using A000 (writing to 0x000d). Note that the mmu is left in edit mode, so the trampolines can just write to 000d with no disabling of interrupts.</blockquote>

=== Oscar64 ===
<blockquote>Oscar64 is a C/C++ cross compiler running on a modern system (such as a Windows PC, Mac or Linux machine) and targets the classic 6502 family of processors. It is mainly focused on Commodore systems such as the C64, PET or VIC20. The compiler supports C99 and many C++ features up to variadic templates and lambda functions.

The purpose of this compiler is to eliminate the need to write 6502 assembler code to achieve high code density and fast execution speed. It continues to improve with all the games, demos and tools written by it. It supports disk overlays and banked cartridges for larger projects.

Oscar64 was adapted for the F256/WildBits by swdfrost and [https://github.com/sdwfrost/oscar64 here is a link its github page]. You will also need the adaptation of the f256lib (ported over from llvm-mos) [https://github.com/sdwfrost/f256lib-oscar64 from this github page] as well, which also includes many projects examples as well. </blockquote>

==== Getting set up on Windows 10/11 (-Mu0n) ====
<blockquote>Assumptions:

* Windows' WSL is installed (ie with Ubuntu)
* Python is installed inside windows
* make is installed inside WSL
* gcc is installed inside WSL ('''sudo apt install build-essential''')
</blockquote>
Step 1) in Windows, make a base directory (let's call it '''BASEPATH''') that will hold both:

* the oscar64 project, but with the 'f256k-support' branch rather than 'main' branch <nowiki>https://github.com/sdwfrost/oscar64</nowiki>

* the f256lib-oscar64 project, 'main branch' <nowiki>https://github.com/sdwfrost/f256lib-oscar64</nowiki>

(both from sdwfrost's GitHub account)

Step 2) from windows, open a cmd window, go to your intended base folder Step 3) type WSL Step 4) clone oscar64 with

'''git clone -b f256k-support <nowiki>https://github.com/sdwfrost/oscar64.git</nowiki>'''

Step 5) clone f256lib-oscar64 side by side in the same base folder.

'''git clone -b main <nowiki>https://github.com/sdwfrost/f256lib-oscar64</nowiki>'''

Both '<nowiki/>'''oscar64'''<nowiki/>' and ''''f256lib-oscar64'''<nowiki/>' folders will be in the same location when this is done.

Step 6) go into oscar64/

Step 7) type:

'''make -f make/makefile'''

(this assumes gcc being present in WSL, it will take a while!)

Step 8) switch over to f256lib-oscar64/ and type:

'''OSCAR64=../../oscar64/bin/oscar64 make all'''

(warning 1: at the time of writing this guide, the 2nd project, BachHero, triggers an error that halts the whole list. Simply remove that entry from /f256lib-oscar64/doodles/MakeFile to get the rest going) (warning 2: most projects will compile, but not run properly when run in the Wildbits environment since they expect extra library files that have not been ported over)

Step 9) to compile a single project in general, make sure you use a path that points to the compiled oscar64 of step 7 like so: (assuming your project myproject is in BASEPATH/f256lib-oscar64/doodles/)

'''BASEPATH/oscar64/bin/oscar64 -tm=f256k -n -i=BASEPATH/f256lib-oscar64/f256lib BASEPATH/f256lib-oscar64/doodles/myproject/src/myproject.c'''

C Development

2026-03-21T14:38:20Z

1BitFeverDreams: /* List of "Gotchas" for llvm-mos */

== '''C Compilers''' ==
* [[cc65]]
* [https://www.calypsi.cc/ Calypsi]
* [[llvm-mos]]
* oscar64

=== LLVM-MOS ===
This fork of llvm-mos was adapted for F256/Wildbits usage by user sduensing from Kangaroo Punch Studios and [https://kangaroopunch.com/view/ShowSoftware?id=13 can be found here]. The installation instructions are simple and work for both Windows and Linux. It mostly uses a one-stop-shop f256lib.h file containing macros and functions leveraging some devices (not all yet) and the MicroKernel.

The default linking configuration will have your code start at 0x300, a 8 kb stack/trampoline from 0xA000 to 0xBFFF that is used to bring in higher memory content visible into that slice of the first 64k of the CPU. The slice 0xC000 to 0xDFFF is used by IO as usual and 0xE000 to 0xFFFF is used by the MicroKernel as usual. To change any of this, you can bring a modified copy of link.ld into your /projectfolder/ and it will supersede this default mapping.<blockquote>
==== List of "Gotchas" for llvm-mos ====
1) When trying to use the EMBED directive in order to put data at specific memory locations, keep in mind that you CAN'T comment those lines out with <code>/*</code> and <code>*/</code>, the compiler will try to follow them whether they're in them or not. The only way to comment them is to use <code>//</code>.

2) When trying to use the EMBED directive, you may want to put your assets in a subfolder of your project. As in, assuming your source files are in ./src/ (where '.' is the root of your project) and your assets are in ./assets/, then you WILL need to refer to your asset files like so: <code>EMBED(myassetname, "../assets/myassetfile.bin", 0x10000);</code>. Note the weird ../ folder backtracking that has to be used. No other combination worked for me (-Mu0n)

3) In the f256dev/ folder, the f256build.bat file contains all you need to compile and link your project. In the "call mos-f256-clang.bat" line, one important switch is the optimization level you let the compiler use. Experiment with -O1 (no optimization), -O2 (some) and -O3 (most). Some operations and repetitions work with some and fail with others. One prominent example of where it failed was a repetitive fileRead operation that read and parsed little chunks of data from a file, byte by byte and while it compiled and linked, it failed during execution. By reducing -O3 to -O2, it all worked again.

4) One linking error kept giving me "<code>ld.lld: error: ld-temp.o <inline asm>:2:1: operand must be a 16-bit address sta (mos8(.LpickAudioFile_zp_stk+4)</code>" despite not having written any inline assembly in my project. You can skirt around the issue for the problematic function by adding a compiler attribute: <code>__attribute__((optnone))</code> right before your function definition.

5) When your code nears a size of 0x9400 and above, you may get in trouble in terms of code not being fully loaded into RAM while executing. Either deliberately put some code into far memory and devise a scheme with the MMU to swap that code in and out of reach for the CPU, or you can carve yourself a bit more space by editing f256dev/llvm-mos/mos-platform/f256/lib/link.ld and change:

<code>/* fake C Stack */</code>

<code>PROVIDE(__stack = 0xA000);</code>

<code>to</code>

<code>/* fake C Stack */</code>

<code>PROVIDE(__stack = 0xC000);</code>

to get yourself an extra 8k of code space before it collides with the stack

6) The compiler will often complain about a missing closing curly bracket '}' at the end of your source files. Just add the one it requires at the very end even though it's an extra one, or, finish your source file by putting your last function with this notation:

<code>void myLastFunction(uint8_t whatever) {</code>

<code>//bunchacode</code>

<code>}</code></blockquote><blockquote>
==== jbaker8935's guide on creating trampolines for functions in higher memory: ====

what you can do is pick a function in one of your projects that isnt time critical and create a trampoline function for it using this pattern:

void FAR8_video_init(void);

<pre>
#pragma clang optimize off
__attribute__((noinline))
void video_init(void) {
volatile unsigned char ___mmu = (unsigned char)*(volatile unsigned char *)0x000d;
*(volatile unsigned char *)0x000d = 8;
FAR8_video_init();
*(volatile unsigned char *)0x000d = ___mmu;
}
#pragma clang optimize on

__attribute__((noinline, section(".block8")))
void FAR8_video_init(void)
</pre>

note: that FAR8_video_init is the renamed function that is being moved. It's just a convention.
in your main you can call video_init as you do normally and the trampoline will take care of swapping the code into A000 in cpu memory.
For linking you need to create file f256.ld that sits in the project directory. it is a copy of "${ROOT}/llvm-mos/mos-platform/f256/lib/link.ld" but has additional linker instructions to explain how to deal with block8. à
Around line 100 or so you need to add instructions after the include output.ld statement. like so:

<pre>
/* Overlay Segments and Binary Data */
INCLUDE output.ld

/* Hand Coded output.ld records */
SHORT(8*0x2000)
BYTE(8/8)
SHORT(end_block8 - __block8_lma)
BYTE(0x00)
TRIM(block8)
</pre>

i'm using f256build.sh and the normal 'everything in src' structure. Also I didnt fiddle with moving the default stack or swap page, so this example trampoline is using A000 (writing to 0x000d). Note that the mmu is left in edit mode, so the trampolines can just write to 000d with no disabling of interrupts.</blockquote>

=== Oscar64 ===
<blockquote>Oscar64 is a C/C++ cross compiler running on a modern system (such as a Windows PC, Mac or Linux machine) and targets the classic 6502 family of processors. It is mainly focused on Commodore systems such as the C64, PET or VIC20. The compiler supports C99 and many C++ features up to variadic templates and lambda functions.

The purpose of this compiler is to eliminate the need to write 6502 assembler code to achieve high code density and fast execution speed. It continues to improve with all the games, demos and tools written by it. It supports disk overlays and banked cartridges for larger projects.

Oscar64 was adapted for the F256/WildBits by swdfrost and [https://github.com/sdwfrost/oscar64 here is a link its github page]. You will also need the adaptation of the f256lib (ported over from llvm-mos) [https://github.com/sdwfrost/f256lib-oscar64 from this github page] as well, which also includes many projects examples as well. </blockquote>

==== Getting set up on Windows 10/11 (-Mu0n) ====
<blockquote>Assumptions:

* Windows' WSL is installed (ie with Ubuntu)
* Python is installed inside windows
* make is installed inside WSL
* gcc is installed inside WSL ('''sudo apt install build-essential''')
</blockquote>

Step 1) in Windows, make a base directory (let's call it BASEPATH) that will hold both:

<nowiki/>* the oscar64 project, but with the 'f256k-support' branch rather than 'main' branch
<nowiki>https://github.com/sdwfrost/oscar64</nowiki>

<nowiki/>* the f256lib-oscar64 project, 'main branch'
<nowiki>https://github.com/sdwfrost/f256lib-oscar64</nowiki>

(both from sdwfrost's GitHub account)

Step 2) from windows, open a cmd window, go to your intended base folder
Step 3) type WSL
Step 4) clone oscar64 with

'''git clone -b f256k-support <nowiki>https://github.com/sdwfrost/oscar64.git</nowiki>'''

Step 5) clone f256lib-oscar64 side by side in the same base folder.

'''git clone -b main <nowiki>https://github.com/sdwfrost/f256lib-oscar64</nowiki>'''

Both 'oscar64' and 'f256lib-oscar64' folders will be in the same location when this is done.

Step 6) go into oscar64/

Step 7) type:

'''make -f make/makefile'''

(this assumes gcc being present in WSL, it will take a while!)

Step 8) switch over to f256lib-oscar64/ and type:

'''OSCAR64=../../oscar64/bin/oscar64 make all'''

(warning 1: at the time of writing this guide, the 2nd project, BachHero, triggers an error that halts the whole list. Simply remove that entry from '''/f256lib-oscar64/doodles/MakeFile''' to get the rest going)
(warning 2: most projects will compile, but not run properly when run in the Wildbits environment since they expect extra library files that have not been ported over)

Step 9) to compile a single project in general, make sure you use a path that points to the compiled '''oscar64''' of step 7 like so:
(assuming your project '''myproject''' is in '''BASEPATH/f256lib-oscar64/doodles/''')

'''BASEPATH/oscar64/bin/oscar64 -tm=f256k -n -i=BASEPATH/f256lib-oscar64/f256lib BASEPATH/f256lib-oscar64/doodles/myproject/src/myproject.c'''

C Development

2026-03-21T14:37:31Z

1BitFeverDreams: /* Oscar64 */

== '''C Compilers''' ==
* [[cc65]]
* [https://www.calypsi.cc/ Calypsi]
* [[llvm-mos]]
* oscar64

=== LLVM-MOS ===
This fork of llvm-mos was adapted for F256/Wildbits usage by user sduensing from Kangaroo Punch Studios and [https://kangaroopunch.com/view/ShowSoftware?id=13 can be found here]. The installation instructions are simple and work for both Windows and Linux. It mostly uses a one-stop-shop f256lib.h file containing macros and functions leveraging some devices (not all yet) and the MicroKernel.

The default linking configuration will have your code start at 0x300, a 8 kb stack/trampoline from 0xA000 to 0xBFFF that is used to bring in higher memory content visible into that slice of the first 64k of the CPU. The slice 0xC000 to 0xDFFF is used by IO as usual and 0xE000 to 0xFFFF is used by the MicroKernel as usual. To change any of this, you can bring a modified copy of link.ld into your /projectfolder/ and it will supersede this default mapping.

==== List of "Gotchas" for llvm-mos ====
1) When trying to use the EMBED directive in order to put data at specific memory locations, keep in mind that you CAN'T comment those lines out with <code>/*</code> and <code>*/</code>, the compiler will try to follow them whether they're in them or not. The only way to comment them is to use <code>//</code>.

2) When trying to use the EMBED directive, you may want to put your assets in a subfolder of your project. As in, assuming your source files are in ./src/ (where '.' is the root of your project) and your assets are in ./assets/, then you WILL need to refer to your asset files like so: <code>EMBED(myassetname, "../assets/myassetfile.bin", 0x10000);</code>. Note the weird ../ folder backtracking that has to be used. No other combination worked for me (-Mu0n)

3) In the f256dev/ folder, the f256build.bat file contains all you need to compile and link your project. In the "call mos-f256-clang.bat" line, one important switch is the optimization level you let the compiler use. Experiment with -O1 (no optimization), -O2 (some) and -O3 (most). Some operations and repetitions work with some and fail with others. One prominent example of where it failed was a repetitive fileRead operation that read and parsed little chunks of data from a file, byte by byte and while it compiled and linked, it failed during execution. By reducing -O3 to -O2, it all worked again.

4) One linking error kept giving me "<code>ld.lld: error: ld-temp.o <inline asm>:2:1: operand must be a 16-bit address sta (mos8(.LpickAudioFile_zp_stk+4)</code>" despite not having written any inline assembly in my project. You can skirt around the issue for the problematic function by adding a compiler attribute: <code>__attribute__((optnone))</code> right before your function definition.

5) When your code nears a size of 0x9400 and above, you may get in trouble in terms of code not being fully loaded into RAM while executing. Either deliberately put some code into far memory and devise a scheme with the MMU to swap that code in and out of reach for the CPU, or you can carve yourself a bit more space by editing f256dev/llvm-mos/mos-platform/f256/lib/link.ld and change:

<code>/* fake C Stack */</code>

<code>PROVIDE(__stack = 0xA000);</code>

<code>to</code>

<code>/* fake C Stack */</code>

<code>PROVIDE(__stack = 0xC000);</code>

to get yourself an extra 8k of code space before it collides with the stack

6) The compiler will often complain about a missing closing curly bracket '}' at the end of your source files. Just add the one it requires at the very end even though it's an extra one, or, finish your source file by putting your last function with this notation:

<code>void myLastFunction(uint8_t whatever) {</code>

<code>//bunchacode</code>

<code>}</code>

==== jbaker8935's guide on creating trampolines for functions in higher memory: ====

what you can do is pick a function in one of your projects that isnt time critical and create a trampoline function for it using this pattern:

void FAR8_video_init(void);

<pre>
#pragma clang optimize off
__attribute__((noinline))
void video_init(void) {
volatile unsigned char ___mmu = (unsigned char)*(volatile unsigned char *)0x000d;
*(volatile unsigned char *)0x000d = 8;
FAR8_video_init();
*(volatile unsigned char *)0x000d = ___mmu;
}
#pragma clang optimize on

__attribute__((noinline, section(".block8")))
void FAR8_video_init(void)
</pre>

note: that FAR8_video_init is the renamed function that is being moved. It's just a convention.
in your main you can call video_init as you do normally and the trampoline will take care of swapping the code into A000 in cpu memory.
For linking you need to create file f256.ld that sits in the project directory. it is a copy of "${ROOT}/llvm-mos/mos-platform/f256/lib/link.ld" but has additional linker instructions to explain how to deal with block8. à
Around line 100 or so you need to add instructions after the include output.ld statement. like so:

<pre>
/* Overlay Segments and Binary Data */
INCLUDE output.ld

/* Hand Coded output.ld records */
SHORT(8*0x2000)
BYTE(8/8)
SHORT(end_block8 - __block8_lma)
BYTE(0x00)
TRIM(block8)
</pre>

i'm using f256build.sh and the normal 'everything in src' structure. Also I didnt fiddle with moving the default stack or swap page, so this example trampoline is using A000 (writing to 0x000d). Note that the mmu is left in edit mode, so the trampolines can just write to 000d with no disabling of interrupts.

=== Oscar64 ===
Oscar64 is a C/C++ cross compiler running on a modern system (such as a Windows PC, Mac or Linux machine) and targets the classic 6502 family of processors. It is mainly focused on Commodore systems such as the C64, PET or VIC20. The compiler supports C99 and many C++ features up to variadic templates and lambda functions.

The purpose of this compiler is to eliminate the need to write 6502 assembler code to achieve high code density and fast execution speed. It continues to improve with all the games, demos and tools written by it. It supports disk overlays and banked cartridges for larger projects.

Oscar64 was adapted for the F256/WildBits by swdfrost and [https://github.com/sdwfrost/oscar64 here is a link its github page]. You will also need the adaptation of the f256lib (ported over from llvm-mos) [https://github.com/sdwfrost/f256lib-oscar64 from this github page] as well, which also includes many projects examples as well.

==== Getting set up on Windows 10/11 (-Mu0n) ====
Assumptions:

* Windows' WSL is installed (ie with Ubuntu)
* Python is installed inside windows
* make is installed inside WSL
* gcc is installed inside WSL ('''sudo apt install build-essential''')

Step 1) in Windows, make a base directory (let's call it BASEPATH) that will hold both:

<nowiki/>* the oscar64 project, but with the 'f256k-support' branch rather than 'main' branch
<nowiki>https://github.com/sdwfrost/oscar64</nowiki>

<nowiki/>* the f256lib-oscar64 project, 'main branch'
<nowiki>https://github.com/sdwfrost/f256lib-oscar64</nowiki>

(both from sdwfrost's GitHub account)

Step 2) from windows, open a cmd window, go to your intended base folder
Step 3) type WSL
Step 4) clone oscar64 with

'''git clone -b f256k-support <nowiki>https://github.com/sdwfrost/oscar64.git</nowiki>'''

Step 5) clone f256lib-oscar64 side by side in the same base folder.

'''git clone -b main <nowiki>https://github.com/sdwfrost/f256lib-oscar64</nowiki>'''

Both 'oscar64' and 'f256lib-oscar64' folders will be in the same location when this is done.

Step 6) go into oscar64/

Step 7) type:

'''make -f make/makefile'''

(this assumes gcc being present in WSL, it will take a while!)

Step 8) switch over to f256lib-oscar64/ and type:

'''OSCAR64=../../oscar64/bin/oscar64 make all'''

(warning 1: at the time of writing this guide, the 2nd project, BachHero, triggers an error that halts the whole list. Simply remove that entry from '''/f256lib-oscar64/doodles/MakeFile''' to get the rest going)
(warning 2: most projects will compile, but not run properly when run in the Wildbits environment since they expect extra library files that have not been ported over)

Step 9) to compile a single project in general, make sure you use a path that points to the compiled '''oscar64''' of step 7 like so:
(assuming your project '''myproject''' is in '''BASEPATH/f256lib-oscar64/doodles/''')

'''BASEPATH/oscar64/bin/oscar64 -tm=f256k -n -i=BASEPATH/f256lib-oscar64/f256lib BASEPATH/f256lib-oscar64/doodles/myproject/src/myproject.c'''

C Development

2026-03-21T14:37:15Z

1BitFeverDreams:

== '''C Compilers''' ==
* [[cc65]]
* [https://www.calypsi.cc/ Calypsi]
* [[llvm-mos]]
* oscar64

=== LLVM-MOS ===
This fork of llvm-mos was adapted for F256/Wildbits usage by user sduensing from Kangaroo Punch Studios and [https://kangaroopunch.com/view/ShowSoftware?id=13 can be found here]. The installation instructions are simple and work for both Windows and Linux. It mostly uses a one-stop-shop f256lib.h file containing macros and functions leveraging some devices (not all yet) and the MicroKernel.

The default linking configuration will have your code start at 0x300, a 8 kb stack/trampoline from 0xA000 to 0xBFFF that is used to bring in higher memory content visible into that slice of the first 64k of the CPU. The slice 0xC000 to 0xDFFF is used by IO as usual and 0xE000 to 0xFFFF is used by the MicroKernel as usual. To change any of this, you can bring a modified copy of link.ld into your /projectfolder/ and it will supersede this default mapping.

==== List of "Gotchas" for llvm-mos ====
1) When trying to use the EMBED directive in order to put data at specific memory locations, keep in mind that you CAN'T comment those lines out with <code>/*</code> and <code>*/</code>, the compiler will try to follow them whether they're in them or not. The only way to comment them is to use <code>//</code>.

2) When trying to use the EMBED directive, you may want to put your assets in a subfolder of your project. As in, assuming your source files are in ./src/ (where '.' is the root of your project) and your assets are in ./assets/, then you WILL need to refer to your asset files like so: <code>EMBED(myassetname, "../assets/myassetfile.bin", 0x10000);</code>. Note the weird ../ folder backtracking that has to be used. No other combination worked for me (-Mu0n)

3) In the f256dev/ folder, the f256build.bat file contains all you need to compile and link your project. In the "call mos-f256-clang.bat" line, one important switch is the optimization level you let the compiler use. Experiment with -O1 (no optimization), -O2 (some) and -O3 (most). Some operations and repetitions work with some and fail with others. One prominent example of where it failed was a repetitive fileRead operation that read and parsed little chunks of data from a file, byte by byte and while it compiled and linked, it failed during execution. By reducing -O3 to -O2, it all worked again.

4) One linking error kept giving me "<code>ld.lld: error: ld-temp.o <inline asm>:2:1: operand must be a 16-bit address sta (mos8(.LpickAudioFile_zp_stk+4)</code>" despite not having written any inline assembly in my project. You can skirt around the issue for the problematic function by adding a compiler attribute: <code>__attribute__((optnone))</code> right before your function definition.

5) When your code nears a size of 0x9400 and above, you may get in trouble in terms of code not being fully loaded into RAM while executing. Either deliberately put some code into far memory and devise a scheme with the MMU to swap that code in and out of reach for the CPU, or you can carve yourself a bit more space by editing f256dev/llvm-mos/mos-platform/f256/lib/link.ld and change:

<code>/* fake C Stack */</code>

<code>PROVIDE(__stack = 0xA000);</code>

<code>to</code>

<code>/* fake C Stack */</code>

<code>PROVIDE(__stack = 0xC000);</code>

to get yourself an extra 8k of code space before it collides with the stack

6) The compiler will often complain about a missing closing curly bracket '}' at the end of your source files. Just add the one it requires at the very end even though it's an extra one, or, finish your source file by putting your last function with this notation:

<code>void myLastFunction(uint8_t whatever) {</code>

<code>//bunchacode</code>

<code>}</code>

==== jbaker8935's guide on creating trampolines for functions in higher memory: ====

what you can do is pick a function in one of your projects that isnt time critical and create a trampoline function for it using this pattern:<blockquote>void FAR8_video_init(void);

<pre>
#pragma clang optimize off
__attribute__((noinline))
void video_init(void) {
volatile unsigned char ___mmu = (unsigned char)*(volatile unsigned char *)0x000d;
*(volatile unsigned char *)0x000d = 8;
FAR8_video_init();
*(volatile unsigned char *)0x000d = ___mmu;
}
#pragma clang optimize on

__attribute__((noinline, section(".block8")))
void FAR8_video_init(void)
</pre>

note: that FAR8_video_init is the renamed function that is being moved. It's just a convention.
in your main you can call video_init as you do normally and the trampoline will take care of swapping the code into A000 in cpu memory.
For linking you need to create file f256.ld that sits in the project directory. it is a copy of "${ROOT}/llvm-mos/mos-platform/f256/lib/link.ld" but has additional linker instructions to explain how to deal with block8. à
Around line 100 or so you need to add instructions after the include output.ld statement. like so:

<pre>
/* Overlay Segments and Binary Data */
INCLUDE output.ld

/* Hand Coded output.ld records */
SHORT(8*0x2000)
BYTE(8/8)
SHORT(end_block8 - __block8_lma)
BYTE(0x00)
TRIM(block8)
</pre>

i'm using f256build.sh and the normal 'everything in src' structure. Also I didnt fiddle with moving the default stack or swap page, so this example trampoline is using A000 (writing to 0x000d). Note that the mmu is left in edit mode, so the trampolines can just write to 000d with no disabling of interrupts.

=== Oscar64 ===
Oscar64 is a C/C++ cross compiler running on a modern system (such as a Windows PC, Mac or Linux machine) and targets the classic 6502 family of processors. It is mainly focused on Commodore systems such as the C64, PET or VIC20. The compiler supports C99 and many C++ features up to variadic templates and lambda functions.

The purpose of this compiler is to eliminate the need to write 6502 assembler code to achieve high code density and fast execution speed. It continues to improve with all the games, demos and tools written by it. It supports disk overlays and banked cartridges for larger projects.

Oscar64 was adapted for the F256/WildBits by swdfrost and [https://github.com/sdwfrost/oscar64 here is a link its github page]. You will also need the adaptation of the f256lib (ported over from llvm-mos) [https://github.com/sdwfrost/f256lib-oscar64 from this github page] as well, which also includes many projects examples as well.

==== Getting set up on Windows 10/11 (-Mu0n) ====
Assumptions:

* Windows' WSL is installed (ie with Ubuntu)
* Python is installed inside windows
* make is installed inside WSL
* gcc is installed inside WSL ('''sudo apt install build-essential''')

Step 1) in Windows, make a base directory (let's call it BASEPATH) that will hold both:

* the oscar64 project, but with the 'f256k-support' branch rather than 'main' branch
<nowiki>https://github.com/sdwfrost/oscar64</nowiki>

* the f256lib-oscar64 project, 'main branch'
<nowiki>https://github.com/sdwfrost/f256lib-oscar64</nowiki>

(both from sdwfrost's GitHub account)

Step 2) from windows, open a cmd window, go to your intended base folder
Step 3) type WSL
Step 4) clone oscar64 with

'''git clone -b f256k-support <nowiki>https://github.com/sdwfrost/oscar64.git</nowiki>'''

Step 5) clone f256lib-oscar64 side by side in the same base folder.

'''git clone -b main <nowiki>https://github.com/sdwfrost/f256lib-oscar64</nowiki>'''

Both 'oscar64' and 'f256lib-oscar64' folders will be in the same location when this is done.

Step 6) go into oscar64/

Step 7) type:

'''make -f make/makefile'''

(this assumes gcc being present in WSL, it will take a while!)

Step 8) switch over to f256lib-oscar64/ and type:

'''OSCAR64=../../oscar64/bin/oscar64 make all'''

(warning 1: at the time of writing this guide, the 2nd project, BachHero, triggers an error that halts the whole list. Simply remove that entry from '''/f256lib-oscar64/doodles/MakeFile''' to get the rest going)
(warning 2: most projects will compile, but not run properly when run in the Wildbits environment since they expect extra library files that have not been ported over)

Step 9) to compile a single project in general, make sure you use a path that points to the compiled '''oscar64''' of step 7 like so:
(assuming your project '''myproject''' is in '''BASEPATH/f256lib-oscar64/doodles/''')

'''BASEPATH/oscar64/bin/oscar64 -tm=f256k -n -i=BASEPATH/f256lib-oscar64/f256lib BASEPATH/f256lib-oscar64/doodles/myproject/src/myproject.c'''

C Development

2026-03-21T14:36:27Z

1BitFeverDreams: indent was weird for the oscar64 section

== '''C Compilers''' ==
* [[cc65]]
* [https://www.calypsi.cc/ Calypsi]
* [[llvm-mos]]
* oscar64

=== LLVM-MOS ===
This fork of llvm-mos was adapted for F256/Wildbits usage by user sduensing from Kangaroo Punch Studios and [https://kangaroopunch.com/view/ShowSoftware?id=13 can be found here]. The installation instructions are simple and work for both Windows and Linux. It mostly uses a one-stop-shop f256lib.h file containing macros and functions leveraging some devices (not all yet) and the MicroKernel.

The default linking configuration will have your code start at 0x300, a 8 kb stack/trampoline from 0xA000 to 0xBFFF that is used to bring in higher memory content visible into that slice of the first 64k of the CPU. The slice 0xC000 to 0xDFFF is used by IO as usual and 0xE000 to 0xFFFF is used by the MicroKernel as usual. To change any of this, you can bring a modified copy of link.ld into your /projectfolder/ and it will supersede this default mapping.

==== List of "Gotchas" for llvm-mos ====
1) When trying to use the EMBED directive in order to put data at specific memory locations, keep in mind that you CAN'T comment those lines out with <code>/*</code> and <code>*/</code>, the compiler will try to follow them whether they're in them or not. The only way to comment them is to use <code>//</code>.

2) When trying to use the EMBED directive, you may want to put your assets in a subfolder of your project. As in, assuming your source files are in ./src/ (where '.' is the root of your project) and your assets are in ./assets/, then you WILL need to refer to your asset files like so: <code>EMBED(myassetname, "../assets/myassetfile.bin", 0x10000);</code>. Note the weird ../ folder backtracking that has to be used. No other combination worked for me (-Mu0n)

3) In the f256dev/ folder, the f256build.bat file contains all you need to compile and link your project. In the "call mos-f256-clang.bat" line, one important switch is the optimization level you let the compiler use. Experiment with -O1 (no optimization), -O2 (some) and -O3 (most). Some operations and repetitions work with some and fail with others. One prominent example of where it failed was a repetitive fileRead operation that read and parsed little chunks of data from a file, byte by byte and while it compiled and linked, it failed during execution. By reducing -O3 to -O2, it all worked again.

4) One linking error kept giving me "<code>ld.lld: error: ld-temp.o <inline asm>:2:1: operand must be a 16-bit address sta (mos8(.LpickAudioFile_zp_stk+4)</code>" despite not having written any inline assembly in my project. You can skirt around the issue for the problematic function by adding a compiler attribute: <code>__attribute__((optnone))</code> right before your function definition.

5) When your code nears a size of 0x9400 and above, you may get in trouble in terms of code not being fully loaded into RAM while executing. Either deliberately put some code into far memory and devise a scheme with the MMU to swap that code in and out of reach for the CPU, or you can carve yourself a bit more space by editing f256dev/llvm-mos/mos-platform/f256/lib/link.ld and change:

<code>/* fake C Stack */</code>

<code>PROVIDE(__stack = 0xA000);</code>

<code>to</code>

<code>/* fake C Stack */</code>

<code>PROVIDE(__stack = 0xC000);</code>

to get yourself an extra 8k of code space before it collides with the stack

6) The compiler will often complain about a missing closing curly bracket '}' at the end of your source files. Just add the one it requires at the very end even though it's an extra one, or, finish your source file by putting your last function with this notation:

<code>void myLastFunction(uint8_t whatever) {</code>

<code>//bunchacode</code>

<code>}</code>

==== jbaker8935's guide on creating trampolines for functions in higher memory: ====

what you can do is pick a function in one of your projects that isnt time critical and create a trampoline function for it using this pattern:<blockquote>void FAR8_video_init(void);

<pre>
#pragma clang optimize off
__attribute__((noinline))
void video_init(void) {
volatile unsigned char ___mmu = (unsigned char)*(volatile unsigned char *)0x000d;
*(volatile unsigned char *)0x000d = 8;
FAR8_video_init();
*(volatile unsigned char *)0x000d = ___mmu;
}
#pragma clang optimize on

__attribute__((noinline, section(".block8")))
void FAR8_video_init(void)
</pre>

note: that FAR8_video_init is the renamed function that is being moved. It's just a convention.
in your main you can call video_init as you do normally and the trampoline will take care of swapping the code into A000 in cpu memory.
For linking you need to create file f256.ld that sits in the project directory. it is a copy of "${ROOT}/llvm-mos/mos-platform/f256/lib/link.ld" but has additional linker instructions to explain how to deal with block8. à
Around line 100 or so you need to add instructions after the include output.ld statement. like so:

<pre>
/* Overlay Segments and Binary Data */
INCLUDE output.ld

/* Hand Coded output.ld records */
SHORT(8*0x2000)
BYTE(8/8)
SHORT(end_block8 - __block8_lma)
BYTE(0x00)
TRIM(block8)
</pre>

i'm using f256build.sh and the normal 'everything in src' structure. Also I didnt fiddle with moving the default stack or swap page, so this example trampoline is using A000 (writing to 0x000d). Note that the mmu is left in edit mode, so the trampolines can just write to 000d with no disabling of interrupts.

=== Oscar64 ===
<blockquote>Oscar64 is a C/C++ cross compiler running on a modern system (such as a Windows PC, Mac or Linux machine) and targets the classic 6502 family of processors. It is mainly focused on Commodore systems such as the C64, PET or VIC20. The compiler supports C99 and many C++ features up to variadic templates and lambda functions.

The purpose of this compiler is to eliminate the need to write 6502 assembler code to achieve high code density and fast execution speed. It continues to improve with all the games, demos and tools written by it. It supports disk overlays and banked cartridges for larger projects.

Oscar64 was adapted for the F256/WildBits by swdfrost and [https://github.com/sdwfrost/oscar64 here is a link its github page]. You will also need the adaptation of the f256lib (ported over from llvm-mos) [https://github.com/sdwfrost/f256lib-oscar64 from this github page] as well, which also includes many projects examples as well.

==== Getting set up on Windows 10/11 (-Mu0n) ====
Assumptions:

* Windows' WSL is installed (ie with Ubuntu)
* Python is installed inside windows
* make is installed inside WSL
* gcc is installed inside WSL ('''sudo apt install build-essential''')

Step 1) in Windows, make a base directory (let's call it BASEPATH) that will hold both:

* the oscar64 project, but with the 'f256k-support' branch rather than 'main' branch
<nowiki>https://github.com/sdwfrost/oscar64</nowiki>

* the f256lib-oscar64 project, 'main branch'
<nowiki>https://github.com/sdwfrost/f256lib-oscar64</nowiki>

(both from sdwfrost's GitHub account)

Step 2) from windows, open a cmd window, go to your intended base folder
Step 3) type WSL
Step 4) clone oscar64 with

'''git clone -b f256k-support <nowiki>https://github.com/sdwfrost/oscar64.git</nowiki>'''

Step 5) clone f256lib-oscar64 side by side in the same base folder.

'''git clone -b main <nowiki>https://github.com/sdwfrost/f256lib-oscar64</nowiki>'''

Both 'oscar64' and 'f256lib-oscar64' folders will be in the same location when this is done.

Step 6) go into oscar64/

Step 7) type:

'''make -f make/makefile'''

(this assumes gcc being present in WSL, it will take a while!)

Step 8) switch over to f256lib-oscar64/ and type:

'''OSCAR64=../../oscar64/bin/oscar64 make all'''

(warning 1: at the time of writing this guide, the 2nd project, BachHero, triggers an error that halts the whole list. Simply remove that entry from '''/f256lib-oscar64/doodles/MakeFile''' to get the rest going)
(warning 2: most projects will compile, but not run properly when run in the Wildbits environment since they expect extra library files that have not been ported over)

Step 9) to compile a single project in general, make sure you use a path that points to the compiled '''oscar64''' of step 7 like so:
(assuming your project '''myproject''' is in '''BASEPATH/f256lib-oscar64/doodles/''')

'''BASEPATH/oscar64/bin/oscar64 -tm=f256k -n -i=BASEPATH/f256lib-oscar64/f256lib BASEPATH/f256lib-oscar64/doodles/myproject/src/myproject.c'''

C Development

2026-03-21T14:34:33Z

1BitFeverDreams: added oscar64 and reorganized sections for llvm-mos

== '''C Compilers''' ==
* [[cc65]]
* [https://www.calypsi.cc/ Calypsi]
* [[llvm-mos]]
* oscar64

=== LLVM-MOS ===
This fork of llvm-mos was adapted for F256/Wildbits usage by user sduensing from Kangaroo Punch Studios and [https://kangaroopunch.com/view/ShowSoftware?id=13 can be found here]. The installation instructions are simple and work for both Windows and Linux. It mostly uses a one-stop-shop f256lib.h file containing macros and functions leveraging some devices (not all yet) and the MicroKernel.

The default linking configuration will have your code start at 0x300, a 8 kb stack/trampoline from 0xA000 to 0xBFFF that is used to bring in higher memory content visible into that slice of the first 64k of the CPU. The slice 0xC000 to 0xDFFF is used by IO as usual and 0xE000 to 0xFFFF is used by the MicroKernel as usual. To change any of this, you can bring a modified copy of link.ld into your /projectfolder/ and it will supersede this default mapping.

==== List of "Gotchas" for llvm-mos ====
1) When trying to use the EMBED directive in order to put data at specific memory locations, keep in mind that you CAN'T comment those lines out with <code>/*</code> and <code>*/</code>, the compiler will try to follow them whether they're in them or not. The only way to comment them is to use <code>//</code>.

2) When trying to use the EMBED directive, you may want to put your assets in a subfolder of your project. As in, assuming your source files are in ./src/ (where '.' is the root of your project) and your assets are in ./assets/, then you WILL need to refer to your asset files like so: <code>EMBED(myassetname, "../assets/myassetfile.bin", 0x10000);</code>. Note the weird ../ folder backtracking that has to be used. No other combination worked for me (-Mu0n)

3) In the f256dev/ folder, the f256build.bat file contains all you need to compile and link your project. In the "call mos-f256-clang.bat" line, one important switch is the optimization level you let the compiler use. Experiment with -O1 (no optimization), -O2 (some) and -O3 (most). Some operations and repetitions work with some and fail with others. One prominent example of where it failed was a repetitive fileRead operation that read and parsed little chunks of data from a file, byte by byte and while it compiled and linked, it failed during execution. By reducing -O3 to -O2, it all worked again.

4) One linking error kept giving me "<code>ld.lld: error: ld-temp.o <inline asm>:2:1: operand must be a 16-bit address sta (mos8(.LpickAudioFile_zp_stk+4)</code>" despite not having written any inline assembly in my project. You can skirt around the issue for the problematic function by adding a compiler attribute: <code>__attribute__((optnone))</code> right before your function definition.

5) When your code nears a size of 0x9400 and above, you may get in trouble in terms of code not being fully loaded into RAM while executing. Either deliberately put some code into far memory and devise a scheme with the MMU to swap that code in and out of reach for the CPU, or you can carve yourself a bit more space by editing f256dev/llvm-mos/mos-platform/f256/lib/link.ld and change:

<code>/* fake C Stack */</code>

<code>PROVIDE(__stack = 0xA000);</code>

<code>to</code>

<code>/* fake C Stack */</code>

<code>PROVIDE(__stack = 0xC000);</code>

to get yourself an extra 8k of code space before it collides with the stack

6) The compiler will often complain about a missing closing curly bracket '}' at the end of your source files. Just add the one it requires at the very end even though it's an extra one, or, finish your source file by putting your last function with this notation:

<code>void myLastFunction(uint8_t whatever) {</code>

<code>//bunchacode</code>

<code>}</code>

==== jbaker8935's guide on creating trampolines for functions in higher memory: ====

what you can do is pick a function in one of your projects that isnt time critical and create a trampoline function for it using this pattern:<blockquote>void FAR8_video_init(void);

<pre>
#pragma clang optimize off
__attribute__((noinline))
void video_init(void) {
volatile unsigned char ___mmu = (unsigned char)*(volatile unsigned char *)0x000d;
*(volatile unsigned char *)0x000d = 8;
FAR8_video_init();
*(volatile unsigned char *)0x000d = ___mmu;
}
#pragma clang optimize on

__attribute__((noinline, section(".block8")))
void FAR8_video_init(void)
</pre>

note: that FAR8_video_init is the renamed function that is being moved. It's just a convention.
in your main you can call video_init as you do normally and the trampoline will take care of swapping the code into A000 in cpu memory.
For linking you need to create file f256.ld that sits in the project directory. it is a copy of "${ROOT}/llvm-mos/mos-platform/f256/lib/link.ld" but has additional linker instructions to explain how to deal with block8. à
Around line 100 or so you need to add instructions after the include output.ld statement. like so:

<pre>
/* Overlay Segments and Binary Data */
INCLUDE output.ld

/* Hand Coded output.ld records */
SHORT(8*0x2000)
BYTE(8/8)
SHORT(end_block8 - __block8_lma)
BYTE(0x00)
TRIM(block8)
</pre>

i'm using f256build.sh and the normal 'everything in src' structure. Also I didnt fiddle with moving the default stack or swap page, so this example trampoline is using A000 (writing to 0x000d). Note that the mmu is left in edit mode, so the trampolines can just write to 000d with no disabling of interrupts.

=== Oscar64 ===
Oscar64 is a C/C++ cross compiler running on a modern system (such as a Windows PC, Mac or Linux machine) and targets the classic 6502 family of processors. It is mainly focused on Commodore systems such as the C64, PET or VIC20. The compiler supports C99 and many C++ features up to variadic templates and lambda functions.

The purpose of this compiler is to eliminate the need to write 6502 assembler code to achieve high code density and fast execution speed. It continues to improve with all the games, demos and tools written by it. It supports disk overlays and banked cartridges for larger projects.

Oscar64 was adapted for the F256/WildBits by swdfrost and [https://github.com/sdwfrost/oscar64 here is a link its github page]. You will also need the adaptation of the f256lib (ported over from llvm-mos) [https://github.com/sdwfrost/f256lib-oscar64 from this github page] as well, which also includes many projects examples as well.

==== Getting set up on Windows 10/11 (-Mu0n) ====
Assumptions:

* Windows' WSL is installed (ie with Ubuntu)
* Python is installed inside windows
* make is installed inside WSL
* gcc is installed inside WSL ('''sudo apt install build-essential''')

Step 1) in Windows, make a base directory (let's call it BASEPATH) that will hold both:

* the oscar64 project, but with the 'f256k-support' branch rather than 'main' branch
<nowiki>https://github.com/sdwfrost/oscar64</nowiki>

* the f256lib-oscar64 project, 'main branch'
<nowiki>https://github.com/sdwfrost/f256lib-oscar64</nowiki>

(both from sdwfrost's GitHub account)

Step 2) from windows, open a cmd window, go to your intended base folder
Step 3) type WSL
Step 4) clone oscar64 with

'''git clone -b f256k-support <nowiki>https://github.com/sdwfrost/oscar64.git</nowiki>'''

Step 5) clone f256lib-oscar64 side by side in the same base folder.

'''git clone -b main <nowiki>https://github.com/sdwfrost/f256lib-oscar64</nowiki>'''

Both 'oscar64' and 'f256lib-oscar64' folders will be in the same location when this is done.

Step 6) go into oscar64/

Step 7) type:

'''make -f make/makefile'''

(this assumes gcc being present in WSL, it will take a while!)

Step 8) switch over to f256lib-oscar64/ and type:

'''OSCAR64=../../oscar64/bin/oscar64 make all'''

(warning 1: at the time of writing this guide, the 2nd project, BachHero, triggers an error that halts the whole list. Simply remove that entry from '''/f256lib-oscar64/doodles/MakeFile''' to get the rest going)
(warning 2: most projects will compile, but not run properly when run in the Wildbits environment since they expect extra library files that have not been ported over)

Step 9) to compile a single project in general, make sure you use a path that points to the compiled '''oscar64''' of step 7 like so:
(assuming your project '''myproject''' is in '''BASEPATH/f256lib-oscar64/doodles/''')

'''BASEPATH/oscar64/bin/oscar64 -tm=f256k -n -i=BASEPATH/f256lib-oscar64/f256lib BASEPATH/f256lib-oscar64/doodles/myproject/src/myproject.c'''

Raspberry Pi Pico Update

2026-02-14T15:29:44Z

1BitFeverDreams: warning for header rip

== Raspberry Pi Pico Update ==

=== Overview ===

There is an onboard RP2040 chip (pi pico). It is NOT PRESENT on the Jr2. It's only present on the K2. It's responsible for the following things:

* the bootloader procedure that loads the right core while booting the K2.
* it is also known as the "FPGA Manager"
* Has modifiable code that can invite more features and possibly a faster bootup

=== Preparing new pico flash files ===

Check this [https://github.com/wildbitscomputing/fpga-manager fpga manager] repo from Cibee which can tweak and compile such files into .uf2. This project uses VSCode, the pico sdk and openocd in order to do everything.

Here's a summary of the booting time gains that were accomplished by Cibee (see the benchmark table on the side)

bit bang (slowest): was the old method, at launch of the K2, of sending a core file to the FPGA.

pio (faster): is the new method tried by Cibee

SD raw (slowest): was the old way of storing the core file, uncompressed, as .bin files. See [[FPGA_Releases#How_to_Upgrade_the_FPGA_for_the_F256K2]] for the exact file structure needed inside the internal "left" uSD card.

SD gzip (faster): is a new method of individually storing those same core files as .bin.gzip, reducing the amount of bytes to send dramatically

FLASH LZ4 (fastest): is embedding the core files inside the pi pico flash memory so that the core manager carries its own data and sends it to the fpga during bootup. This no longer involves the internal "left" uSD card at all.

When a recent enough fpga manager (January 2026) is flashed into the pi pico, it will try to prepare the fpga with this following sequence:

<nowiki>*</nowiki> Reads a 2-bit context DIP switch to select one of four FPGA slots.

<nowiki>*</nowiki> Attempts SD card programming first (LZ4 blocks, gzip, then raw .bin).

<nowiki>*</nowiki> Falls back to LZ4 images stored in fixed flash slots if SD is unavailable.

<nowiki>*</nowiki> Prints the chosen method and timing over USB stdio if enabled.
[[File:FPGA Manager Benchmark.png|thumb]]

=== Opening the case ===

You can refer to this section to learn how you can be [[Opening_the_F256K_case]]

=== Flashing using the onboard USB Header ===

Here are the steps to follow:
[[File:Rp2040-cable.jpeg|thumb|Connector location for the pico USB pin header, Switch S3 on the left, and cable orientation]]
Installation step:

* Install Cable as above (F256K2 Powered Off). '''WARNING''', with '''VERY LITTLE''' cable tension, this pin header can snap off [from Mu0n] and force you onto the next method of flashing using the SWD header, as seen in the next section.
* Plug Cable in any PC that holds the new programming file.
* Keep 1 finger on the button
* Power the F256K2
* A new folder will appear on the PC's Desktop
* Drop the new .uf2 file in the newly appeared folder.
* Power off F256K2
* Remove cable
* Reinstall the system as your heart's desire
* Power On the unit
* RP2040 is updated and running (because you need it to boot the unit)
* Bob's your uncle!

=== Flashing using the onboard SWD Header ===

SWD: Serial Wire Debug. This other pin header is a second way to update your flash and gives a little more flexibility to do it piece by piece by flashing .bin at specific flash locations or .elf in one go.
[[File:Swd connector.png|thumb|Connector location for the SWD pin header, near the FPGA]]

You'll need either:

* a [https://www.raspberrypi.com/documentation/microcontrollers/debug-probe.html Pi Debug Probe] which comes with the necessary cable that leads to 3 female Dupont endings needed here
* openocd tool from PicoSDK v1.5.1 or more recent
* a prepared .bin file with updated code.
* a conversion tool to convert .uf2 to .bin, you can use this website https://polpo.org/tmp/uf2-to-bin.html or other known tools in the pico community
* the key step is to use openocd like so: openocd -s scripts -f interface/cmsis-dap.cfg -f target/rp2040.cfg -c "adapter speed 5000; program NewFirmware.bin verify reset exit 0x10000000"

Raspberry Pi Pico Update

2026-02-14T15:27:09Z

1BitFeverDreams: /* Raspberry Pi Pico Update */

== Raspberry Pi Pico Update ==

=== Overview ===

There is an onboard RP2040 chip (pi pico). It is NOT PRESENT on the Jr2. It's only present on the K2. It's responsible for the following things:

* the bootloader procedure that loads the right core while booting the K2.
* it is also known as the "FPGA Manager"
* Has modifiable code that can invite more features and possibly a faster bootup

=== Preparing new pico flash files ===

Check this [https://github.com/wildbitscomputing/fpga-manager fpga manager] repo from Cibee which can tweak and compile such files into .uf2. This project uses VSCode, the pico sdk and openocd in order to do everything.

Here's a summary of the booting time gains that were accomplished by Cibee (see the benchmark table on the side)

bit bang (slowest): was the old method, at launch of the K2, of sending a core file to the FPGA.

pio (faster): is the new method tried by Cibee

SD raw (slowest): was the old way of storing the core file, uncompressed, as .bin files. See [[FPGA_Releases#How_to_Upgrade_the_FPGA_for_the_F256K2]] for the exact file structure needed inside the internal "left" uSD card.

SD gzip (faster): is a new method of individually storing those same core files as .bin.gzip, reducing the amount of bytes to send dramatically

FLASH LZ4 (fastest): is embedding the core files inside the pi pico flash memory so that the core manager carries its own data and sends it to the fpga during bootup. This no longer involves the internal "left" uSD card at all.

When a recent enough fpga manager (January 2026) is flashed into the pi pico, it will try to prepare the fpga with this following sequence:

<nowiki>*</nowiki> Reads a 2-bit context DIP switch to select one of four FPGA slots.

<nowiki>*</nowiki> Attempts SD card programming first (LZ4 blocks, gzip, then raw .bin).

<nowiki>*</nowiki> Falls back to LZ4 images stored in fixed flash slots if SD is unavailable.

<nowiki>*</nowiki> Prints the chosen method and timing over USB stdio if enabled.
[[File:FPGA Manager Benchmark.png|thumb]]

=== Opening the case ===

You can refer to this section to learn how you can be [[Opening_the_F256K_case]]

=== Flashing using the onboard USB Header ===

Here are the steps to follow:
[[File:Rp2040-cable.jpeg|thumb|Connector location for the pico USB pin header, Switch S3 on the left, and cable orientation]]
Installation step:

* Install Cable as above (F256K2 Powered Off)
* Plug Cable in any PC that holds the new programming file.
* Keep 1 finger on the button
* Power the F256K2
* A new folder will appear on the PC's Desktop
* Drop the new .uf2 file in the newly appeared folder.
* Power off F256K2
* Remove cable
* Reinstall the system as your heart's desire
* Power On the unit
* RP2040 is updated and running (because you need it to boot the unit)
* Bob's your uncle!

=== Flashing using the onboard SWD Header ===

SWD: Serial Wire Debug. This other pin header is a second way to update your flash and gives a little more flexibility to do it piece by piece by flashing .bin at specific flash locations or .elf in one go.
[[File:Swd connector.png|thumb|Connector location for the SWD pin header, near the FPGA]]

You'll need either:

* a [https://www.raspberrypi.com/documentation/microcontrollers/debug-probe.html Pi Debug Probe] which comes with the necessary cable that leads to 3 female Dupont endings needed here
* openocd tool from PicoSDK v1.5.1 or more recent
* a prepared .bin file with updated code.
* a conversion tool to convert .uf2 to .bin, you can use this website https://polpo.org/tmp/uf2-to-bin.html or other known tools in the pico community
* the key step is to use openocd like so: openocd -s scripts -f interface/cmsis-dap.cfg -f target/rp2040.cfg -c "adapter speed 5000; program NewFirmware.bin verify reset exit 0x10000000"

File:Swd connector.png

2026-02-14T15:26:09Z

1BitFeverDreams:

Serial Wire Debug header populated. This cable leads to a Pi Debug Probe

File:FPGA Manager Benchmark.png

2026-02-14T15:15:21Z

1BitFeverDreams:

Provides booting time comparisons according to the strategy in bringing a core file to the FPGA

Raspberry Pi Pico Update

2026-02-14T15:13:38Z

1BitFeverDreams:

== Raspberry Pi Pico Update ==

=== Overview ===

There is an onboard RP2040 chip (pi pico). It is not present on the Jr2. It's responsible for the following things:

* the bootloader procedure that loads the right core while booting the K2.
* it is also known as the "FPGA Manager"
* Contains the K2 LCD screen special bitmap to be shown at bootup
* Has modifiable code that can invite more features and possibly a faster bootup

=== Preparing new pico flash files ===

Check this [https://github.com/wildbitscomputing/fpga-manager fpga manager] repo from Cibee which can tweak and compile such files into .uf2. This project uses VSCode, the pico sdk and openocd in order to do everything.

Here's a summary of the booting time gains that were accomplished by Cibee:

[[File:Fpga Manager Benchmark.png|thumb]]

=== Opening the case ===

You can refer to this section to learn how you can be [[Opening_the_F256K_case]]

=== Flashing using the onboard USB Header ===

Here are the steps to follow:
[[File:Rp2040-cable.jpeg|thumb|Connector location, Switch S3 on the left, and cable orientation]]
Installation step:

* Install Cable as above (F256K2 Powered Off)
* Plug Cable in any PC that holds the new programming file.
* Keep 1 finger on the button
* Power the F256K2
* A new folder will appear on the PC's Desktop
* Drop the new .uf2 file in the newly appeared folder.
* Power off F256K2
* Remove cable
* Reinstall the system as your heart's desire
* Power On the unit
* RP2040 is updated and running (because you need it to boot the unit)
* Bob's your uncle!

=== Flashing using the onboard SWD Header ===

SWD: Serial Wire Debug. This other pin header is a second way to update your flash and gives a little more flexibility to do it piece by piece by flashing .bin at specific flash locations or .elf in one go.

You'll need either:

* a [https://www.raspberrypi.com/documentation/microcontrollers/debug-probe.html Pi Debug Probe] which comes with the necessary cable that leads to 3 female Dupont endings needed here
* openocd tool from PicoSDK v1.5.1 or more recent
* a prepared .bin file with updated code.
* a conversion tool to convert .uf2 to .bin, you can use this website https://polpo.org/tmp/uf2-to-bin.html or other known tools in the pico community
* the key step is to use openocd like so: openocd -s scripts -f interface/cmsis-dap.cfg -f target/rp2040.cfg -c "adapter speed 5000; program NewFirmware.bin verify reset exit 0x10000000"

File:Fpga Manager Benchmark.png

2026-02-14T15:13:17Z

1BitFeverDreams:

describes booting times in relation to the strategy of getting fpga cores to the fpga

Firmware

2026-02-14T14:59:22Z

1BitFeverDreams: moving the RP2040 firmware to its own hardware maintenance page

== System Flash ROM ==
The Foenix F256K, Jr., K2 and Jr2 computers contain 512K of flash memory which is intended to store software which should be available to the user without any media like SD-cards or IEC drives present. Think of it like a space traditionally occupied by ROM chips of 80's computers containing critical, often used programs and routines, but instead of being very rarely updated with scarce ROM chip revisions, it can be quickly updated with firmware revisions using the FoenixMgr python scripts.

'''Important Note''': for the F256K2, each core has its own dedicated area of 512K of flash memory. When switching to a new core, a separate dedicated area of 512K exists for that core and there's an expectation that the process of flashing the firmware has to be done for it.

This collection of software can be changed by the user by simply reprogramming the flash "ROM". At the moment (2025+) the following applications are stored in flash as a default loadout:
{| class="wikitable"
|+Collection of 6502/65816 firmware programs as of firmware release version 2025.13
!Absolute Block* in Memory Map
!Block* Offset in onboard Flash
!Name of program
!Description
|-
|0x40
|0x00
|'''''reserved'''''
|
|-
|0x41
|0x01
|xdev
|trampoline program meant to react to developper scripts from [[FoenixMgr]]: pcopy, runpgz, runpgx
|-
|0x42 to 0x45
|0x02 to 0x05
|superbasic
|if xdev has nothing to react to, superbasic is your default startup program
|-
|0x46
|0x06
|dos
|minimalistic file management and info shell
|-
|0x47
|0x07
|'''''free'''''
|
|-
|0x48
|0x08
|fcart
|allows a user to flash the 256K Flast Cart with 8kb prepared blocks. See [[CartFlasher|this for usage]]
|-
|0x49
|0x09
|'''free'''
|
|-
|0x4A
|0x0A
|help
|text help on screen for superbasic programming
|-
|0x4B to 0x4E
|0x0B to 0x0E
|'''''free'''''
|
|-
|0x4F
|0x0F
|wget
|web get, works only for gen1 K and Jr equipped with a feather wifi board
|-
|0x50 to 0x56
|0x10 to 0x16
|fm
|f/manager - a rather feature rich file manipulation, program launcher and memory exploration software
|-
|0x57
|0x17
|'''''free'''''
|
|-
|0x58 to 0x5B
|0x18 to 0x1B
|mless
|moreorless - a text editor. See [[Moreorless|here for more information.]]
|-
|0x5D to 0x7B
|0x1D to 0x3B
|'''''free'''''
|
|-
|0x7C to 0x7F
|0x3C to 0x3F
|microkernel
|the microkernel, gadget's masterpiece used by many programs
|}
<nowiki>*</nowiki>Block: each block of flash memory is 8kb is size

To reprogram the flash, you can start with the [https://github.com/FoenixRetro/f256-firmware/releases official firmware releases in this github.]

This repo is part the [https://github.com/FoenixRetro FoenixRetro] Github organisation which in turn is an attempt to gather forks of all projects which are part of the firmware and other resources relevant for the Foenix F256 new retro computers.

There are now two firmware loads available: Gen1 - for K and Jr and Gen2 - for K2 and Jr2. The only difference between these loads is the superbasic part of the firmware, in order to have a properly identified superbasic startup screen that reflects the exact computer and generation in the logo.

====== Video tutorial: ======
A part of a tutorial video covers updating the firmware as a follow up step to updating the FPGA core, check it at 6:45 and on.

<youtube>pOab0ocKqac</youtube>

==== 6809 firmware: ====
This core has specialized firmware - it is best to ask around in the appropriate channels of the [https://discord.gg/9vjUEGgcUS Foenix discord].

Raspberry Pi Pico Update

2026-02-11T05:09:16Z

1BitFeverDreams: /* Overview */

Raspberry Pi Pico Update

2026-02-11T05:09:04Z

1BitFeverDreams:

Raspberry Pi Pico Update

2026-02-11T05:03:49Z

1BitFeverDreams: Created page with "== Raspberry Pi Pico Update == === Overview === There is an onboard RP2040 chip (pi pico). It is not present on the Jr2. It's responsible for the following things: * the bootloader procedure that loads the right core while booting the K2. * it is also known as the "FPGA Manager" * Contains the K2 LCD screen to be shown at bootup * Has modifiably code that can invite more features and possibly a faster bootup === Opening the case === You can refer to this section t..."

Template:Main2/System Maintenance

2026-02-11T04:53:28Z

1BitFeverDreams: pi pico page

'''System Maintenance'''
* [[FPGA Releases]]
* [[Kernel & SuperBASIC Updates]]
* [[Optional Upgrades]]
* [[Raspberry Pi Pico Update]]
* [[Troubleshooting]]
* [[Wiznet]]

Kernel & SuperBASIC Updates

2026-02-01T20:38:30Z

1BitFeverDreams: better instructions with gen2

== Kernel and/or SuperBASIC Update Links ==

Most people will prefer to rely on curated, prepared firmware collection to flash the whole flash memory blocks all at once, using a community driven firmware release that will routinely also improve superbasic and the Micro-Kernal, among other things. This is what most people will prefer to use.

Here is a complete package of both latest instances (Scripts & bulk.csv files included as well as the foenixmgr utilities to perform the flash), check the '''Releases''' page of the following link:

[https://github.com/FoenixRetro/f256-firmware Complete Package Kernal+SuperBASIC+Apps Link]

If, for some reason, you really want to modify certain parts of the firmware in flash, you could do so piecewise by replacing only the superbasic or only the Micro-Kernel flash blocks. For the vast majority of users, this is NOT needed.

Here are the GitHub Links where you will find the latest F256K / F256Jr Micro-Kernel load and/or SuperBASIC:

[https://github.com/ghackwrench/F256_MicroKernel F256x Micro-Kernel Github Link]

[https://github.com/paulscottrobson/superbasic/releases F256x SuperBASIC Github Link]

== USB Port ==

=== F256 Jr. / F256K ===
You will need to have the XR21B1411 USB Driver for PC/Linux. The MAC is outdated. (Note: Driver is not needed for the F256K2)
[https://www.maxlinear.com/product/interface/uarts/usb-uarts/xr21b1411]

=== F256K2 ===
On the F256K2 the XR21B1411 has been replaced by a FT4232, to allow direct use as a JTAG controller for the FPGA. There are 3 virtual serial ports (channels) enabled. The first connected to the Raspberry PI Nano (on-board) that manages the FPGA loading, the second one is the Debug port, and the third one is the system UART. This means that you only use a data supporting USB-C cable running from a modern computer to the back of the K2, no need for a specialty cable, nor a specialty adapter.

Therefore, on a F256K2 you want to select the second COM port that gets added to your system. As an example, on one Windows 10 system, the F256K2 USB-C connection added ports COM5, COM6 and COM7. All three coming up just as generic FTDI manufacturer USB ports.

=== Update batch file to point at correct port ===
To perform a full Kernel & SuperBASIC update, I simply downloaded the Complete Package (above) and edited the update.bat batch file to instead specify my system's COM6 (i.e. the 2nd added Port).

== Links to Software needed to do update with FoenixMgr (Python Script) ==
Python
[https://www.python.org/]

PySerial
[https://pyserial.readthedocs.io/en/latest/]

Foenix Manager (Collection of Python Scripts to use the USB Debug port)
[https://github.com/pweingar/FoenixMgr]

== Kernel and/or SuperBASIC Update Guide ==

Below, is a short video on how to install the software you will need to be able to reflash your Kernel and/or SuperBASIC.

==== How to Update your F256 Jr. / F256K Short ====

<youtube>Zgyhy_cBsM8</youtube>

==== How to Update your F256 Jr2 / F256K2 Video ====
<youtube>pOab0ocKqac</youtube>
Starting at 6:46, this video dives into updating the firmware for a specific core (each core have their pocket of 512K of flash memory, not shared).

FPGA Releases

2026-02-01T20:29:51Z

1BitFeverDreams: /* How to Upgrade the FPGA for the F256K2 */

# move the FG & BG Text LUT to:

=== Important: ===
Most users will want to consume the "Firmware package relases" (taken from here: https://github.com/FoenixRetro/f256-firmware/releases. ) which contain both the latest of the FPGA releases seen here on this page, and the kernel/base programs intended for the flash memory. The page you're ready here is meant for power user who would want to test back compatibility or attempt some roll-backs in case bugs are found, and for readers who want to learn about the release notes of each new FPGA version.

''(* "Purple" refers to the official 2025+ release of the K2; "Black" refers to the first run of K2B boards sent out to the original F256K owners in late 2024)''

=== Latest FPGA core files for all platforms ===
{| class="wikitable"
! colspan="3" |
==== <big>F256Jr2</big> ====
!
! colspan="3" |
==== <big>F256K2</big> ====
|-
!Core
!Link
!Notes
!
!Core
!Link
!Notes
|-
|6502 MMU
|[https://github.com/Mu0n/F256MiscGoodies/blob/main/fpga/Jr2/Classic/2025-01-07/F256Jr2_MMU_Jan8th_2025_OPL3.mcs 08-Jan-2025]
|OPL3 added
!
|6502 MMU
|Black*: [https://github.com/Mu0n/F256MiscGoodies/blob/main/fpga/K2/CNTX1/2025-02-02/CFP95600C.bin 02-Feb-2025]
Purple*: [https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/fpga/K2Purple/CNTX1/CFP95600C.bin 05-Feb-2025]
|fix Onboard Access to a SPI Flash
LCD Splash Screen
|-
|65816 Ext
|[https://github.com/Mu0n/F256MiscGoodies/blob/main/fpga/Jr2/Extended/2024-12-21/F256Jr2_Ext16_Dec21st_2024.mcs 21-Dec-2025]
|Implementation of the 256Bytes
Copy from Flash to RAM before booting.
!
|65816 Ext
|Black*: [https://github.com/Mu0n/F256MiscGoodies/blob/main/fpga/K2/CNTX2/2025-01-07/CFP95616E.bin 07-Jan-2025]
Purple*: [https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/fpga/K2Purple/CNTX2/CFP95616E.bin 06-Jan-2025]
|Updated access to WS6100
UART for the VS1053B
|-
|65816 Ext 2x
|[https://c256foenix.com/product-category/gen2-core/?v=5435c69ed3bc Buy Here]
|2x CPU speed
layer of 16 bit colored text

hardware line drawing

64 more sprites.
!
|65816 Ext 2x
|Black*: [https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/fpga/K2/CNTX4/F256K2x_Cores_Foenix138_BlackBoard_B3B_July27th_2025.bin 27-Jul-2025]
Purple*: [https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/fpga/K2/CNTX4/F256K2x_Cores_Foenix138_B0C_August4th_2025.bin 4-Aug-2025]
|2x CPU speed
layer of 16 bit colored text

hardware line drawing

64 more sprites.
|-
|6809
|[https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/fpga/Jr2/6809/2025-06-15/F256JrJr_FNX6809_June14th_RC0014_0003.mcs 15-Jun-2025]
|WIFI Speed and Interface (added TX_Empty & RX_Empty Flag)
!
|6809
|Black*: [https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/fpga/K2/CNTX3/NitrOS9_Load_BlackBoardB3B_WifiFixed_Sept4th.bin 04-Sep-2025]
Purple*: [https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/fpga/K2Purple/CNTX3/NitrOS9_Load_PurpleBoardB0C_WifiFixed_Sept4th.bin 04-Sep-2025]
|Wifi fix
|-
! colspan="3" |
==== <big>F256Jr</big> ====
!
! colspan="3" |
==== <big>F256K</big> ====
|-
!Core
!Link
!Notes
!
!Core
!Link
!Notes
|-
|6502 MMU
|[https://github.com/Mu0n/F256MiscGoodies/blob/main/fpga/Jr/Classic/F256M_Wbh_Jan26th_2025_RC20_0100.jic 26-Jan-2025]
|fixes Overlay FONT on top of graphic
with Background Color Enabled
!
|6502 MMU
|[https://github.com/Mu0n/F256MiscGoodies/blob/main/fpga/K/F256Kc_WBh_Jan26th_2025_RC16_0001.jic 26-Jan-2025]
|fixes Overlay FONT on top of graphic
with Background Color Enabled
|-
|65816 Ext 2x
|[https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/fpga/Jr/Extended/F256M_Wbh_Jun24th_2025_RC0100_0002.jic 24-Jun-2025]
|Fixed bugs with register 0x0000 and 0x0001
!
|65816 Ext 2x
|[https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/fpga/K/F256Kc_WBh_Jun23th_RC0100_0003_DualSpeed_CPU.jic 23-Jun-2025]
|Fixed bugs with register 0x0000 and 0x0001
|}

=== Previous FPGA core files for all platforms ===
Use these for testing out older softwares and snooping around for persistant issues.
{| class="wikitable"
|+
! colspan="3" |
==== <big>Previous F256Jr2 Cores</big> ====
|-
!Core
!Link
!Notes
|-
|6809
|[https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/fpga/Jr2/6809/2025-06-13/F256Jr2_FNX6809_June13th_RC0017_0002.mcs 13-Jun-2025]
|Move the FG & BG Text LUT to:

$18_3800 $18_383F TEXT_LUT_FG

$18_3840 $18_387F TEXT_LUT_BG
|-
|6809
|[https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/fpga/Jr2/6809/2025-06-11/F256Jr2_FNX6809_June11th_RC0017_0000.mcs 11-Jun-2025]
|big Wishlist
full access to write back the onboard flash
|-
|6809
|[https://github.com/Mu0n/F256MiscGoodies/blob/main/fpga/Jr2/6809/2025-01-17/F256Jr2_FNX6809_Jan17th_RC0014_0002.mcs 17-Jan-2025]
|Fix for the manual Reset
Fix for the readback of Multiplication Values

Endianess

Changes to: Line/Pixel Position
|}

{| class="wikitable"
|+
! colspan="3" |
==== <big>Previous</big> <big>F256K2</big> <big>Cores</big> ====
|-
!Core
!Link
!Notes
|-
|6502 MMU
|Black*: [https://github.com/Mu0n/F256MiscGoodies/blob/main/fpga/K2/CNTX1/2025-01-08/CFP95600C.bin 08-Jan-2025]
Purple*: n/a
|OPL3 implemented
|-
|6502 MMU
|Black*: [https://github.com/Mu0n/F256MiscGoodies/blob/main/fpga/K2/CNTX1/2025-01-07/CFP95600C.bin 07-Jan-2025]
Purple*: n/a
|Instantiation of the UART for the VS1053B @ $DDB0
|-
|6809
|Black*: [https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/fpga/K2/CNTX3/K2_NitrOS9_Load_BlackBoard_Aug26th.bin 26-Aug-2025]
Purple*: [https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/fpga/K2Purple/CNTX3/FNX6809_First_Release_Aug24th_PurpleBoard.bin 24-Aug-2025]
|This is the preliminary version and only works with a PS/2 keyboard plugged in.
If destined for slot 3, rename the file and put in CNTX3/f256k2t9.bin
|}

{| class="wikitable"
|+
! colspan="3" |
==== <big>Previous F256Jr Cores</big> ====
|-
!Core
!Link
!Notes
|-
|6502 MMU
|[https://github.com/Mu0n/F256MiscGoodies/blob/main/fpga/Jr/Classic/F256M_Wbh_Dec23rd_2023_RC18_0100.jic 23-Dec-2023]
|Tiles fix; shifted by one towards the left.
(0100 = Serial RAM/Flash Select)
|-
|6502 MMU
|[https://github.com/Mu0n/F256MiscGoodies/blob/main/fpga/Jr/Classic/F256M_Wbh_Nov18th_2023_RC17_0100.jic 18-Nov-2023]
|In light of decision to dump the big ticket items and the accessories from the store...

* Removed the very SPI core introduced yesterday to drive the FNXNET51 module.
* Removed the DP memory for the MMU and replace it back with simple Registers, which means that when you reset the system, the MMU, Page0 will be reset back to the way it was. However, the caveat is that if you change between RAM to FLASH MMU default value, you need to do a reset, either a debug reset or General Reset because the MMU is now only 32bytes in Size, so, 4 pages of 8 values.
|-
|6502 MMU
|[https://github.com/Mu0n/F256MiscGoodies/blob/main/fpga/Jr/Classic/F256M_WBh_Nov17th_2023_RC16_0111.jic 17-Nov-2023]
|
* No Write Allowed when Debug Port writes in the MMU Memory Zone
* Incorporation of a new SPI Controller to interface with the FNXNET51 module using the NES/SNES MiniDin9 Connector
* ReSync of the Debug Generated RDY to stop the CPU. (untested)
|-
|6502 MMU
|[https://github.com/Mu0n/F256MiscGoodies/tree/main/fpga/Jr/Classic various older]
|
|-
|65816 Ext 2x
|[https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/fpga/Jr/Extended/F256M_Wbh_Jun17th_2025_RC0100_0001.jic 16-Jun-2025]
|CPU runs at 2x speed at 12 MHz
MUST use a 65816 cpu chip,

will not work with the 6502
|-
|6809
|n/a
|n/a
|}

{| class="wikitable"
|+
! colspan="3" |
==== <big>Previous</big> <big>F256K</big> <big>Cores</big> ====
|-
!Core
!Link
!Notes
|-
|6502 MMU
|[https://github.com/Mu0n/F256MiscGoodies/blob/main/fpga/K/2024-12-23/F256K_WBh_Dec23rd_RevB0x_RC14_0000.jic 23-Dec-2023]

|Tiles fix; shifted by one towards the left.
|-
|6502 MMU
|[https://github.com/Mu0n/F256MiscGoodies/blob/main/fpga/K/F256K_WBh_Dec9th_RevB0x_RC13_0000.jic 09-Dec-2023]
|
* Fixes a problem with Interrupt from timer0 that was working on the Jr.
* Resolves a discrepancy between the F256Jr interrupt block and the F256K.
|-
|6502 MMU
|[https://github.com/Mu0n/F256MiscGoodies/blob/main/fpga/K/F256K_WBh_Nov19th_RevB0x_RC12_0011.jic 19-Nov-2023]
|Corrects the issue with no-response from command $20 & $21 (not being processed in the early parser). The Jr doesn't have the issue.
|-
|6502 MMU
|various older
|
|-
|65816 Ext 2x
|[https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/fpga/K/F256Kc_WBh_Jun18th_2025_RC0100_0000_DualSpeed_CPU.jic 18-Jun-2025]
|CPU runs at 2x speed at 12 MHz
MUST use a 65816 cpu chip,

will not work with the 6502
|-
|6809
|N/A yet
|N/A yet
|}

---old version will be kept at the bottom for a while in case errors are found above---

== FPGA Upgrade Guide ==

==== How to Upgrade the F256K FPGA (and F256Jr) ====
Note that the below Video Guide applies to both the F256K & F256Jr, despite it just being titled F256K.

<youtube>U7bq7t_qjxg</youtube>

You will need to download Quartus Prime Lite 18.1 Edition, since you are going to target a EP4CE15 FPGA (Cyclone 4).

Do not update to the latest version of Quartus Prime Lite, as the latest version doesn’t support that family of FPGA anymore and the software is very big.

Also, one might want to download only the "Intel® Quartus® Prime Programmer and Tools" as opposed to download the whole software by clicking on "Additional Software"

[https://www.intel.com/content/www/us/en/software-kit/665990/intel-quartus-prime-lite-edition-design-software-version-18-1-for-windows.html Intel Quartus Prime Lite Edition 18.1 for Windows]

[https://www.intel.com/content/www/us/en/software-kit/665988/intel-quartus-prime-lite-edition-design-software-version-18-1-for-linux.html Intel Quartus Prime Lite Edition 18.1 for Linux]

==== How to Upgrade the FPGA for the F256K2 ====
It is possible that there will be more graceful methods in the future, but for now, the easiest is to pop off the uSD card found on the left side of the board marked "uSD Card / FPGA Load" and to replace the .bin files inside the directory of the root of that uSD card, using a modern computer.

This is a video guide that covers both upgrade the FPGA cores of the K2 as well as updating the firmware once the FPGA is improved or installed for the first time:

<youtube>pOab0ocKqac</youtube>

This will of course imply that you open up your case. [[Optional Upgrades#Opening the F256K case|There is a guide]] on how to do so for the original F256K enclosure. The F256K2 enclosure is similar.

For those unfamiliar with the process of removing the uSD card from these slide-operation holders here is the process:

1) very gently press down on the middle metal locking slider that goes across on top of the uSD card and slide it towards the left.

2) the uSD card and its locking slider will now open up by rotating towards the left with a hinge on the left side

Inside the root of this uSD card, there are four folders marked as CNTX# where # is a number from 1 to 4. Simply replace the .bin file therein to update any one given core. You may completely ignore .prm files since they do not affect the F256K2.
{| class="wikitable"
|+
!Folder
!Hard coded file name
!Typical* usage
!CPU in the FPGA
|-
|CNTX1
|CFP95600C.bin
|F256 Classic mode with a memory management unit (MMU), where the CPU sees 64k at once
|65816 acting as 6502
|-
|CNTX2
|CFP95616E.bin
|F256 Extended mode with a flat memory map all accessible at once
|65816
|-
|CNTX3
|f256k2t9.bin
|F256 with the 6809 core (planned) or 68000 core (planned)
|6809
|-
|CNTX4
|foenix138.bin
|F256 with 2x CPU speed Extended mode with a flat memory map all accessible at once
|65816
|}

====== Note* on typical usage ======
As long as you keep the proper hard coded names tied to their folder names, you can slide any core to any slot. For example, if you want the 2x core to be in the CTNX2 folder, just rename it appropriately to CFP95616E.bin as you put it into CTNX2/.

====== F256K2 core prep steps: ======

# Take care of placing the bin file in the FPGA load uSD card
# Set the core selecting DIP switches at the back of the unit. Down (towards bottom of the unit) = 0, Up (towards the upper side of the unit) = 1. See below for all possibilities.
# Power up the unit. If this is the first time you're using that core and you've never done step 4 for it, it's normal to not have a properly booted initial software (ie superbasic or otherwise)
# Write the firmware to the content of the flash. Each of the 4 cores have their own 512kb of reserved flash space that are selected at the same time as the core itself from the uSD FPGA load card. Once they are written to, they are set for future usages as you switch between cores and won't require further flash writes, unless you're doing updates.

====== Core selecting DIP switches in the back ======
{| class="wikitable"
|+
!Core 1
!Core 2
!Core 3
!Core 4
|-
|
[[File:Core1.png|thumb]]
|
[[File:Core3.png|thumb]]
|
[[File:Core2.png|thumb]]
|
[[File:Core4.png|thumb]]
|-
|0 0
|1 0
|0 1
|1 1
|}

==== How to Upgrade the FPGA for the F256Jr. the 2nd ====
Go look at this [[FPGA Upgrade Guide (F256JrJr)|guide here in the wiki]].

=== Suggested USB Blaster (K and Jr. only) ===

Earth People Technology
[https://www.amazon.ca/JTAG-Blaster-Intel-Altera-Programmer/dp/B07BZMSZ3G/ref=sr_1_3?crid=WWV8P0OHVCE3&keywords=altera+usb+blaster&qid=1688067039&sprefix=altera+usb+blaster%2Caps%2C113&sr=8-3]
[https://earthpeopletechnology.com/?wpsc-product=ept-2232h-sp-s1]

Terasic USB Blaster (low cost version)
[https://www.digikey.ca/en/products/detail/terasic-inc/P0302/2003484]
[https://www.terasic.com.tw/cgi-bin/page/archive.pl?Language=English&CategoryNo=&No=46#contents]

Chinese Knockoff (please avoid if possible)

=== Open Source blaster software (K and Jr. only) ===

For those who are struggling to program the FPGA with Linux or Apple, Stef found this great tool:

https://github.com/trabucayre/openFPGALoader/releases

Use the SNES/NES controllers

2026-02-01T20:24:43Z

1BitFeverDreams: link to troubleshooting

== NES and SNES controllers ==
The F256 machines can use these controllers provided they are equipped with an optional FNX4N4S breakout adapter (website purchase link no longer active).

The official gamepads of yesteryear work without issue with this and are plentiful in the used market.

Third party modern recreations are sometimes flaky or not working at all. Share you discoveries in the discord!

Super famicom gamepads work very well as substitute for regular SNES gamepads.

If your FNX4N4S adapter box is not working reliably, go check how to resolve a potential issue in the [[Troubleshooting|Troubleshoot]] page.
[[File:Full complement of gamepads.png|thumb|A fully populated FNX4N4S for the F256K2]]

=== Registers ===
{| class="wikitable"
|+
!Register Name
!R/W
!Address
!NES/SNES
!Description
|-
|PAD_CTRL
|W
|0xD880
|both
|Used to trigger a reading and setting the NES/SNES mode
|-
|PAD_STAT
|R
|0xD880
|both
|Used to verify if the triggered polling of gamepad state is done yet
|-
|PAD0
|R
|0xD884
|both
|Buttons statuses: if cleared, they are pressed. If set, they are unpressed.
|-
|PAD0_S
|R
|0xD885
|SNES
|Same deal; unused by NES. Consult button table below
|-
|PAD1
|R
|0xD886
|both
|Buttons statuses: if cleared, they are pressed. If set, they are unpressed.
|-
|PAD1_S
|R
|0xD887
|SNES
|Same deal; unused by NES. Consult button table below
|-
|PAD2
|R
|0xD888
|both
|Buttons statuses: if cleared, they are pressed. If set, they are unpressed.
|-
|PAD2_S
|R
|0xD889
|SNES
|Same deal; unused by NES. Consult button table below
|-
|PAD3
|R
|0xD88A
|both
|Buttons statuses: if cleared, they are pressed. If set, they are unpressed.
|-
|PAD3_S
|R
|0xD88B
|SNES
|Same deal; unused by NES. Consult button table below
|}

=== Control register ===
{| class="wikitable"
|+
!Register Name
!R/W
!Address
!Bit7
!Bit6
!Bit5
!Bit4
!Bit3
!Bit2
!Bit1
!Bit0
|-
|PAD_CTRL
|W
|0xD880
|NES_TRIG
| -
| -
| -
| -
|MODE
| -
|EN
|-
|PAD_STAT
|R
|0xD880
|NES_TRIG
|DONE
| -
| -
| -
|MODE
| -
|EN
|}

==== Control register bit states: ====
{| class="wikitable"
|+
!Bit Name
!If set to 1
!If cleared to 0
|-
|NES_TRIG
|Launches the polling of the states of all buttons
|Stops polling the states of all buttons
|-
|DONE
|The states of the buttons are ready to be read
|The states of the buttons are not ready
|-
|MODE
|SNES data will be used to populate the PAD registers
|NES data will be used to populate the PAD registers
|-
|EN
|Enables the gamepads
|Disables the gamepads
|}

=== Button table ===
{| class="wikitable"
|+
!MODE
!NES/SNES
!Address
!Pad
!Bit7
!Bit6
!Bit5
!Bit4
!Bit3
!Bit2
!Bit1
!Bit0
|-
|0
|NES
|0xD884
|0
|A
|B
|Select
|Start
|Up
|Down
|Left
|Right
|-
|0
|NES
|0xD886
|1
|A
|B
|Select
|Start
|Up
|Down
|Left
|Right
|-
|0
|NES
|0xD888
|2
|A
|B
|Select
|Start
|Up
|Down
|Left
|Right
|-
|0
|NES
|0xD88A
|3
|A
|B
|Select
|Start
|Up
|Down
|Left
|Right
|-
|1
|SNES
|0xD884
|0
|B
|Y
|Select
|Start
|Up
|Down
|Left
|Right
|-
|1
|SNES
|0xD885
|0
|
|
|
|
|A
|X
|L
|R
|-
|1
|SNES
|0xD886
|1
|B
|Y
|Select
|Start
|Up
|Down
|Left
|Right
|-
|1
|SNES
|0xD887
|1
|
|
|
|
|A
|X
|L
|R
|-
|1
|SNES
|0xD888
|2
|B
|Y
|Select
|Start
|Up
|Down
|Left
|Right
|-
|1
|SNES
|0xD889
|2
|
|
|
|
|A
|X
|L
|R
|-
|1
|SNES
|0xD88A
|3
|B
|Y
|Select
|Start
|Up
|Down
|Left
|Right
|-
|1
|SNES
|0xD88B
|3
|
|
|
|
|A
|X
|L
|R
|}
Note: L refers to the left shoulder button and R refers to the right shoulder button.

=== Usage ===
Example 1: polling a NES controller in PAD0 position and checking if A is pressed:

<pre>
POKE(PAD_CTRL, 0b10000001); //trigger, nes mode, enabled
ASM("NOP"); //a necessary delay with the 2x speed core
ASM("NOP"); //a necessary delay with the 2x speed core
POKE(PAD_CTRL, 0b00000001); //clear trigger
while((PEEK(PAD_STAT) & 0x40) == 0) //loop while this bit is cleared
;
if((PEEK(PAD0) & 0x80) == 0) reactToAPressed();
</pre>

Example 2: polling a SNES controller in PAD2 position and checking if X is pressed:

<pre>
POKE(PAD_CTRL, 0b10000101); //trigger, snes mode, enabled
ASM("NOP"); //a necessary delay with the 2x speed core
ASM("NOP"); //a necessary delay with the 2x speed core
POKE(PAD_CTRL, 0b00000101); //clear trigger
while((PEEK(PAD_STAT) & 0x40) == 0) //loop while this bit is cleared
;
if((PEEK(PAD2_S) & 0x04) == 0) reactToXPressed();
</pre>

Example 3: polling both types of controller in rapid succession (allows the usage of all 8 controllers!)

<pre>
//NES section
POKE(PAD_CTRL, 0b10000001); //trigger, nes mode, enabled
ASM("NOP"); //a necessary delay with the 2x speed core
ASM("NOP"); //a necessary delay with the 2x speed core
POKE(PAD_CTRL, 0b00000001); //clear trigger
while((PEEK(PAD_STAT) & 0x40) == 0) //loop while this bit is cleared
;
//section where reactions are made to the various NES presses

//SNES section
POKE(PAD_CTRL, 0b10000101); //trigger, snes mode, enabled
ASM("NOP"); //a necessary delay with the 2x speed core
ASM("NOP"); //a necessary delay with the 2x speed core
POKE(PAD_CTRL, 0b00000101); //clear trigger
while((PEEK(PAD_STAT) & 0x40) == 0) //loop while this bit is cleared
;
//section where reactions are made to the various SNES presses
</pre>

=== Source code example in C: ===
Check out this simple example displaying the statuses of all 4 NES pads on screen, using hex: https://github.com/Mu0n/F256KsimpleCdoodles/tree/main/NES/src

Troubleshooting

2026-02-01T20:22:18Z

1BitFeverDreams:

== TroubleShooting ==

=== General issues ===
* '''Sometimes, when turning on the F256K/Jr, I get greeted with this screen, from which nothing can happen. How do you resolve this and why does this happen?'''[[File:Microkernel boot screen.png|thumb|Microkernel boot screen]]
* Every time you are powering off and on your unit, the FPGA needs to reprogram itself and that takes time (i.e. Not Instantaneous). It's possible to have faulty loading because the power supply is not quite stable; the RTC that generates the reset is not aligned with the rest of the system. If you are doing a quick on and off, the capacitors are not empty enough to create a rising power rail so the reset can do its things. Unfortunately those are not ASICs, so nothing is instantaneous.

=== FNX4N4S issues ===

* '''Can't seem to make the gamepad work reliably, or one button press affects multiple buttons and triggers at once'''
* After the first batch of these in 2023, the cabling changed and the differing wire colors induced some errors in the wiring inside the FNX4N4S case. The solution is to follow @Cibee's work and make sure you tie these 2 sets of pins the right way:

{| class="wikitable"
|+
!FNX4N4S pins inside,
marked CN1
!DIN9 pins outside the cable,
while facing the pins
!original 2023 run wire colors
!latest 2024-5 run wire colors
|-
|1
|1
|blue
|blue
|-
|2
|6
|red
|red
|-
|3
|2
|white
|green
|-
|4
|7
|brown
|brown
|-
|5
|3
|green
|orange
|-
|6
|8
|purple
|purple
|-
|7
|4
|orange
|yellow
|-
|8
|9
|black
|black
|-
|9
|5
|yellow
|white
|}
[[File:Fnx4n4s inside.png|thumb|Inside the FNX4N4S adapter box with the top cover removed. CN1 is where the cable is soldered directly on the PCB.]]
[[File:Fnx4n4s realcable.png|thumb|Facing the pins of the DIN9 cable of the FNX4N4S adapter box, from the outside.]]
*

Troubleshooting

2026-02-01T20:19:35Z

1BitFeverDreams: fixed DIN9 image

=== General issues ===
* '''Sometimes, when turning on the F256K/Jr, I get greeted with this screen, from which nothing can happen. How do you resolve this and why does this happen?'''[[File:Microkernel boot screen.png|thumb|Microkernel boot screen]]
* Every time you are powering off and on your unit, the FPGA needs to reprogram itself and that takes time (i.e. Not Instantaneous). It's possible to have faulty loading because the power supply is not quite stable; the RTC that generates the reset is not aligned with the rest of the system. If you are doing a quick on and off, the capacitors are not empty enough to create a rising power rail so the reset can do its things. Unfortunately those are not ASICs, so nothing is instantaneous.

==== FNX4N4S issues ====

* '''Can't seem to make the gamepad work reliably, or one button press affects multiple buttons and triggers at once'''
* After the first batch of these in 2023, the cabling changed and the differing wire colors induced some errors in the wiring inside the FNX4N4S case. The solution is to follow @Cibee's work and make sure you tie these 2 sets of pins the right way:

{| class="wikitable"
|+
!FNX4N4S pins inside,
marked CN1
!DIN9 pins outside the cable,
while facing the pins
!original 2023 run wire colors
!latest 2024-5 run wire colors
|-
|1
|1
|blue
|blue
|-
|2
|6
|red
|red
|-
|3
|2
|white
|green
|-
|4
|7
|brown
|brown
|-
|5
|3
|green
|orange
|-
|6
|8
|purple
|purple
|-
|7
|4
|orange
|yellow
|-
|8
|9
|black
|black
|-
|9
|5
|yellow
|white
|}
[[File:Fnx4n4s inside.png|thumb|Inside the FNX4N4S adapter box with the top cover removed. CN1 is where the cable is soldered directly on the PCB.]]
[[File:Fnx4n4s realcable.png|thumb|Facing the pins of the DIN9 cable of the FNX4N4S adapter box, from the outside.]]
*

File:Fnx4n4s realcable.png

2026-02-01T20:19:01Z

1BitFeverDreams:

Facing the pins of the DIN9 cable of the FNX4N4S adapter box, from the outside

Troubleshooting

2026-02-01T20:16:22Z

1BitFeverDreams: FNX4N4S issue added, work by Cibee and Aleskey

=== General issues ===
* '''Sometimes, when turning on the F256K/Jr, I get greeted with this screen, from which nothing can happen. How do you resolve this and why does this happen?'''[[File:Microkernel boot screen.png|thumb|Microkernel boot screen]]
* Every time you are powering off and on your unit, the FPGA needs to reprogram itself and that takes time (i.e. Not Instantaneous). It's possible to have faulty loading because the power supply is not quite stable; the RTC that generates the reset is not aligned with the rest of the system. If you are doing a quick on and off, the capacitors are not empty enough to create a rising power rail so the reset can do its things. Unfortunately those are not ASICs, so nothing is instantaneous.

==== FNX4N4S issues ====

* '''Can't seem to make the gamepad work reliably, or one button press affects multiple buttons and triggers at once'''
* After the first batch of these in 2023, the cabling changed and the differing wire colors induced some errors in the wiring inside the FNX4N4S case. The solution is to follow @Cibee's work and make sure you tie these 2 sets of pins the right way:

{| class="wikitable"
|+
!FNX4N4S pins inside,
marked CN1
!DIN9 pins outside the cable,
while facing the pins
!original 2023 run wire colors
!latest 2024-5 run wire colors
|-
|1
|1
|blue
|blue
|-
|2
|6
|red
|red
|-
|3
|2
|white
|green
|-
|4
|7
|brown
|brown
|-
|5
|3
|green
|orange
|-
|6
|8
|purple
|purple
|-
|7
|4
|orange
|yellow
|-
|8
|9
|black
|black
|-
|9
|5
|yellow
|white
|}
[[File:Fnx4n4s inside.png|thumb|Inside the FNX4N4S adapter box with the top cover removed. CN1 is where the cable is soldered directly on the PCB.]]
[[File:Fnx4n4s cable.jpg|thumb|Facing the pins of the DIN9 cable of the FNX4N4S adapter box, from the outside.]]

*

File:Fnx4n4s cable.jpg

2026-02-01T20:15:45Z

1BitFeverDreams:

Facing the pins from the outside of the DIN9 plug of the FNX4N4S adapter box.

File:Fnx4n4s inside.png

2026-02-01T20:14:22Z

1BitFeverDreams:

Inside the case for the FNX4N4S adapter

Optional Upgrades

2026-02-01T20:04:12Z

1BitFeverDreams: /* Feather Huzzah Wifi module (ESP8266) */

== F256 Optional Upgrades ==

=== Opening the F256K case ===

To open the top half of the case, you will need a torx security size 8 screwdriver bit.
To further disassemble the main board and take it out of the bottom half of the case, you will also need a Phillips size 1 bit and a torx security size 10 bit.
You can check out the whole tear down operation in this video:

<youtube>NXktQHyba84</youtube>

=== CR2032 coin cell battery for Real Time Clock ===

(F256K: requires the top half of the case being removed)

Install a 3V CR2032 battery to enable real time clock operations.

=== CPU integrated chip swap ===

W65C02S

W65C816S

6809 (FPGA on a mini DIP40 board)

=== Feather Huzzah Wifi module (ESP8266) ===

Here's a full video guide on how to configure, solder and install an ESP8266 Feather Huzzah module from Adafruit into the F256K, could also apply to a F256Jr.

'''''As for the F256Jr2 and F256K2, they have their own wifi solutions and would not benefit from this upgrade'''''.

<youtube>gJ9rZczDlfA</youtube>

=== 3.5 mm audio socket for stereo (year one production K and Jr units only) ===

If you have a Jr or K from 2023, chances are, your 3.5 mm audio socket is mono only by mistake. Here's a way to test this out.

Run the following BASIC program:

5 poke $D6A1,4: REM'set PSG_ST register to stereo mode'

10 poke $D600,$9C: REM'silence left channel'

20 poke $D600,$89: poke $D600, $3F:REM'send A2 to left channel'

30 poke $D610,$9C:REM'silence right channel'

40 poke $D610,$8A: poke $D610,$0A:rem'something else to right channel'

while capturing the audio in your favorite modern computer software (ie audacity). If you have stereo, you should clearly see a different tone in each left and right channels. If they're the same mixed tone on both channels, you have a mono socket.

It is possible to desolder the socket and replace a proper one, here are the tips from Stefany:

F256K - Your output will be Mono.

F256Jr - Your output will be working perfectly, but when you want to install an external audio connector on the front bezel, it is not going to work.

For the F256K, the line that could be cut are on the side of the board which means that one would need to desolder the connector to fix the issue.

the fix for f256k is either

1- remove, cut trace, reinstall

2- remove, reinstall the right jack connector
with the right connector, the traces become irrelevent

The right part for the socket is: SJ1-3555NG

*pending video on how to swap this socket on the K*

Use the SNES/NES controllers

2026-02-01T20:02:00Z

1BitFeverDreams: removed link to purchase FNX4N4S, since it no longer works.

== NES and SNES controllers ==
The F256 machines can use these controllers provided they are equipped with an optional FNX4N4S breakout adapter (website purchase link no longer active).

The official gamepads of yesteryear work without issue with this and are plentiful in the used market.

Third party modern recreations are sometimes flaky or not working at all. Share you discoveries in the discord!

Super famicom gamepads work very well as substitute for regular SNES gamepads.
[[File:Full complement of gamepads.png|thumb|A fully populated FNX4N4S for the F256K2]]

=== Registers ===
{| class="wikitable"
|+
!Register Name
!R/W
!Address
!NES/SNES
!Description
|-
|PAD_CTRL
|W
|0xD880
|both
|Used to trigger a reading and setting the NES/SNES mode
|-
|PAD_STAT
|R
|0xD880
|both
|Used to verify if the triggered polling of gamepad state is done yet
|-
|PAD0
|R
|0xD884
|both
|Buttons statuses: if cleared, they are pressed. If set, they are unpressed.
|-
|PAD0_S
|R
|0xD885
|SNES
|Same deal; unused by NES. Consult button table below
|-
|PAD1
|R
|0xD886
|both
|Buttons statuses: if cleared, they are pressed. If set, they are unpressed.
|-
|PAD1_S
|R
|0xD887
|SNES
|Same deal; unused by NES. Consult button table below
|-
|PAD2
|R
|0xD888
|both
|Buttons statuses: if cleared, they are pressed. If set, they are unpressed.
|-
|PAD2_S
|R
|0xD889
|SNES
|Same deal; unused by NES. Consult button table below
|-
|PAD3
|R
|0xD88A
|both
|Buttons statuses: if cleared, they are pressed. If set, they are unpressed.
|-
|PAD3_S
|R
|0xD88B
|SNES
|Same deal; unused by NES. Consult button table below
|}

=== Control register ===
{| class="wikitable"
|+
!Register Name
!R/W
!Address
!Bit7
!Bit6
!Bit5
!Bit4
!Bit3
!Bit2
!Bit1
!Bit0
|-
|PAD_CTRL
|W
|0xD880
|NES_TRIG
| -
| -
| -
| -
|MODE
| -
|EN
|-
|PAD_STAT
|R
|0xD880
|NES_TRIG
|DONE
| -
| -
| -
|MODE
| -
|EN
|}

==== Control register bit states: ====
{| class="wikitable"
|+
!Bit Name
!If set to 1
!If cleared to 0
|-
|NES_TRIG
|Launches the polling of the states of all buttons
|Stops polling the states of all buttons
|-
|DONE
|The states of the buttons are ready to be read
|The states of the buttons are not ready
|-
|MODE
|SNES data will be used to populate the PAD registers
|NES data will be used to populate the PAD registers
|-
|EN
|Enables the gamepads
|Disables the gamepads
|}

=== Button table ===
{| class="wikitable"
|+
!MODE
!NES/SNES
!Address
!Pad
!Bit7
!Bit6
!Bit5
!Bit4
!Bit3
!Bit2
!Bit1
!Bit0
|-
|0
|NES
|0xD884
|0
|A
|B
|Select
|Start
|Up
|Down
|Left
|Right
|-
|0
|NES
|0xD886
|1
|A
|B
|Select
|Start
|Up
|Down
|Left
|Right
|-
|0
|NES
|0xD888
|2
|A
|B
|Select
|Start
|Up
|Down
|Left
|Right
|-
|0
|NES
|0xD88A
|3
|A
|B
|Select
|Start
|Up
|Down
|Left
|Right
|-
|1
|SNES
|0xD884
|0
|B
|Y
|Select
|Start
|Up
|Down
|Left
|Right
|-
|1
|SNES
|0xD885
|0
|
|
|
|
|A
|X
|L
|R
|-
|1
|SNES
|0xD886
|1
|B
|Y
|Select
|Start
|Up
|Down
|Left
|Right
|-
|1
|SNES
|0xD887
|1
|
|
|
|
|A
|X
|L
|R
|-
|1
|SNES
|0xD888
|2
|B
|Y
|Select
|Start
|Up
|Down
|Left
|Right
|-
|1
|SNES
|0xD889
|2
|
|
|
|
|A
|X
|L
|R
|-
|1
|SNES
|0xD88A
|3
|B
|Y
|Select
|Start
|Up
|Down
|Left
|Right
|-
|1
|SNES
|0xD88B
|3
|
|
|
|
|A
|X
|L
|R
|}
Note: L refers to the left shoulder button and R refers to the right shoulder button.

=== Usage ===
Example 1: polling a NES controller in PAD0 position and checking if A is pressed:

<pre>
POKE(PAD_CTRL, 0b10000001); //trigger, nes mode, enabled
ASM("NOP"); //a necessary delay with the 2x speed core
ASM("NOP"); //a necessary delay with the 2x speed core
POKE(PAD_CTRL, 0b00000001); //clear trigger
while((PEEK(PAD_STAT) & 0x40) == 0) //loop while this bit is cleared
;
if((PEEK(PAD0) & 0x80) == 0) reactToAPressed();
</pre>

Example 2: polling a SNES controller in PAD2 position and checking if X is pressed:

<pre>
POKE(PAD_CTRL, 0b10000101); //trigger, snes mode, enabled
ASM("NOP"); //a necessary delay with the 2x speed core
ASM("NOP"); //a necessary delay with the 2x speed core
POKE(PAD_CTRL, 0b00000101); //clear trigger
while((PEEK(PAD_STAT) & 0x40) == 0) //loop while this bit is cleared
;
if((PEEK(PAD2_S) & 0x04) == 0) reactToXPressed();
</pre>

Example 3: polling both types of controller in rapid succession (allows the usage of all 8 controllers!)

<pre>
//NES section
POKE(PAD_CTRL, 0b10000001); //trigger, nes mode, enabled
ASM("NOP"); //a necessary delay with the 2x speed core
ASM("NOP"); //a necessary delay with the 2x speed core
POKE(PAD_CTRL, 0b00000001); //clear trigger
while((PEEK(PAD_STAT) & 0x40) == 0) //loop while this bit is cleared
;
//section where reactions are made to the various NES presses

//SNES section
POKE(PAD_CTRL, 0b10000101); //trigger, snes mode, enabled
ASM("NOP"); //a necessary delay with the 2x speed core
ASM("NOP"); //a necessary delay with the 2x speed core
POKE(PAD_CTRL, 0b00000101); //clear trigger
while((PEEK(PAD_STAT) & 0x40) == 0) //loop while this bit is cleared
;
//section where reactions are made to the various SNES presses
</pre>

=== Source code example in C: ===
Check out this simple example displaying the statuses of all 4 NES pads on screen, using hex: https://github.com/Mu0n/F256KsimpleCdoodles/tree/main/NES/src

Software for 6502

2026-01-31T21:40:23Z

1BitFeverDreams: /* Music */

Note that when an hex address is given, it's meant to instruct as to which address to bload or to send (ie foenixmgr python script) the program (ie a .bin file) to before running it. For extra help on how to run .bin files and almost every possible scheme that has to be used to run program, you can consult this video that's also part of [[Getting Started]], this one: https://www.youtube.com/watch?v=0ShFv89KGDs

Many download links are posts in the main [https://discord.gg/9vjUEGgcUS Foenix Retro Systems discord server] which will require you to join in order to get to them.

A [[Getting Started#Demos Archive|Demo Archive]] was put together in September 2023 to get ready to show to youtubers, some of these are linked once more, in this page.

There's also the Foenix Marketplace website maintained by EMWhite with its own collection of articles and software http://apps.emwhite.org/foenixmarketplace/.

===== Curated SD card collection of games, demos, utilities =====
Here is a download link to a zip file meant to be extracted into the root of an SD card: https://github.com/Mu0n/F256MiscGoodies/tree/main/SDCard_Collection

Best to wipe out your SD card and start anew with the contents of this extracted to root. Micah's file manager doesn't like long lists of files so it really is best to not overdo it. I tried to minimize the files in root, but I couldn't for everything.

Open the readme.txt file with moreorless to see some instructions about the collection. Best to run /- fm first, then open the readme.txt from it

== Applications ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|F256 f/term
|Terminal emulator for F256K and Jr with classic (flat) memory load
|Micah
| - fterm.pgZ or use f/manager
|https://github.com/WartyMN/F256-terminal/blob/main/release/fterm.pgZ
|-
|FoenixTarot
|Tarot card readings in SuperBasic
|Mike
|basic
|https://github.com/mcassera/FoenixTarot/tree/main
|-
|Forthf256
|Forth implementation
|Vasyl
|pgz in its forth/ folder
|https://github.com/VasylTsv/ForthX16
|-
|WildBits Graphic Toolkit
|(fmr. F256-GraphicToolkit) Sprite editor, Tilemap editor, Font editor + misc tools
|econtrerasd
|basic
|https://github.com/econtrerasd/F256-GraphicToolkit/releases
|}

== Demos ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|badapple
|A 80x60 textmode port of Bad Apple, uses the VS1053b for quality mp3 audio. Needs a Jr2 or K2!
|Mu0n
|pgz*
|*unzip badapple.zip into the root of your SD card. If done right, the 3 files within will be in the demos/ folder. The program expects its data file there when it runs. https://github.com/Mu0n/F256MiscGoodies/blob/main/apps/badapple.zip
|-
|balls
|Draw a good quantity of multiplexed sprites, fast. Balls bouncing around
|celton
|pgz
|https://github.com/FoenixRetro/demos/blob/main/MultiplexedSprites.md
|-
|F256Archon
|Splash screen intro, plays MIDI using the SAM2695, requires a K2 or Jr2
|Mu0n
|pgz
|https://github.com/Mu0n/F256Archon/releases
|-
|f256_life
|An implementation of Conway's game of life
|mgr42
|pgz
|https://github.com/rmsk2/f256_life
|-
|F256 Mandelbrot
|Draws Mandelbrot set fast (5 mins) using coprocessor math. Allows to zoom into the set.
|mgr42
|uses basic loader
|https://github.com/rmsk2/F256_Mandelbrot
|-
|F256ShowCase
|Shows sliding tiling graphics, moves with joystick
|eriktier
|$0000
|https://github.com/pig-games/F256Showcase
|-
|fnxmas23
|PSG mod music, scrolling text, sound effects, must see demo!
|dwsJason and digarok
|pgz
|https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/apps/xmas24_k2.pgz revised version that can run on wave 2 Jr2 and K2 as well
|-
|foenixmas23
|Xmas 2023 demo with SID music from the classic 1983 C64 xmas demo
|EMWhite
|uses basic loader
|http://apps.emwhite.org/shared-files/815/?foenixmas23.zip
|-
|livingworlds
|Living Worlds, a port of a color cycling by Mark Ferrari, ported here on the F256 by haydenkale
|haydenkale
|$0000
|https://github.com/clandrew/livingworlds/tree/e4532e0d530b76ccb90368fdf5ad10bfa2deeb12
|-
|mandel
|Will draw a mandelbrot set in 3 hours, more useful as a stability test than a useful fractal program
|Mu0n
|basic
|https://github.com/Mu0n/F256KbasicBASICdoodles?tab=readme-ov-file#fractal
|-
|mariobros
|Tilemap and platformer test based on Mario Bros. (1983)
|beethead
|pgz
|https://github.com/noyen1973/mariobros
|-
|pendulum
|Sprite and MIDI demo
|MikeC
|pgz
|https://github.com/mcassera/pendulum
|-
|wormhole
|Shows a fast wireframe animation of a wormhole
|haydenkale
|pgz or bin at $0000
|https://github.com/clandrew/wormhole?tab=readme-ov-file
|}

== Games ==

{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|bbombers
|Boulder Bombers (Alpha-2) Clone of Canyon Bombers
|Scott (xDraconian)
|pgx
atari joystick
|https://github.com/scttgs0/BoulderBombers<nowiki/>https://github.com/scttgs0/BoulderBombers/releases/tag/alpha_2
|-
|Bombsweeper
|Bomb sweeper port
|beethead
|pgz
|https://discord.com/channels/691915291721990194/855689509520932885/1196352934083035156
|-
|Cosmic
|Shoot 'em up
|beethead
|pgz
|https://discordapp.com/channels/691915291721990194/1054250238308790342/1175982979537969214
|-
|F256-Trek
|Updated Trek, with modern F256 Graphics
|econtrerasd
|basic
|[https://github.com/econtrerasd/Trek-F256/releases/tag/v1.0 https://github.com/econtrerasd/Trek-F256/releases]
|-
|F256 two to the power of eleven
|Port of the puzzle game of 2048
|mgr42
|pgz
|https://github.com/rmsk2/F256_2048<nowiki/>
|-
|fillerup
|Fill 'er Up (WIP)
Qix-like game
|Scott (xDraconian)
|pgx
atari joystick
|https://github.com/scttgs0/Fill-er-up
|-
|FusionDrive
|An outrun type game that also plays a MIDI soundtrack
|Mu0n
|pgz
|wip v0.2, can use a NES pad #1 to move around, or left/right arrow keys currently https://github.com/Mu0n/F256KsimpleCdoodles/tree/main/NoFussDemos
|-
|jewelkeeper
|Sokoban port
|beethead
|pgz
|https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/apps/jewelkeeper.pgz<nowiki/>You can now specify a level file when loading the game <code>/- jewelkeeper.pgz <levels.txt></code>. Find more levels at https://www.sourcecode.se/sokoban/levels.php. Keep in mind the maximum level dimension is 20x15, anything larger will be ignored
|-
|Jr Wördl
|port of Wordle
|AgeAgeEye
|basic
|https://github.com/ageageeye/Superbasic-F256Jr-examples
|-
|kartdemo
|Kart racing game
|SprySloth
|pgz
|https://discord.com/channels/691915291721990194/1225217654487253094/1228246780840513556
|-
|Lair of the Lich King
|Rogue like dungeon crawler. Demo has 3 levels; full has 25+
|Micah
| - lkdemo/lk.pgz
|[https://discord.com/channels/691915291721990194/1230670413361844244/1317256215566487593 1.0 Beta 19 Demo]
|-
|livewire
|Livewire (WIP)
Tempest-like game
|Scott (xDraconian)
|pgx
atari joystick
|https://github.com/scttgs0/Livewire
|-
|Maze-Munch
|Pac-Man clone
|SprySloth
|pgz
|https://github.com/cmassat/Maze-Munch
|-
|pdefense
|Planetary Defense (WIP)
|Scott (xDraconian)
|pgx
mouse
atari joystick
|https://github.com/scttgs0/PlanetaryDefense
|-
|Shanghai/Mahjongg
|A clone of Shanghai. Also known as Mahjongg
|mgr42
|pgz or KUP
mouse needed
|https://github.com/rmsk2/f256_mahjong
|-
|Ski-Jr
|Ski game downhill
|digarok
|basic
|https://github.com/digarok/superbasic-traveler/blob/main/ski-jr.bas
|-
|Track & Field
|Olympic Game by Konami (WIP)
|Scott (xDraconian)
|pgz
atari joystick or keyboard
|
|-
|Tetris
|Good old 80's game
|Daniel Tremblay (Grenouye)
|pgz
atari joystick or keyboard
|https://github.com/dtremblay/c256-tetris/tree/f256k
|}

== Game Jam #01 - April 6th/7th 2024 ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|15puzzle
|Number sort puzzle
|mgr42
|pgz
|https://github.com/rmsk2/f256_15puzzle/releases<nowiki/>
|-
|Flight Simulator
|flying simulator
|sduensin
|pgz
|https://cdn.discordapp.com/attachments/1225481966200029286/1227764847819620454/shotel.pgz
|-
|frisbee
|Frisbee throw past sport game
|dwsJason
|pgz
|https://github.com/dwsJason/f256/blob/develop/merlin32/frisbee/frisbee.pgz
|-
|Impasse
|Shoot 'em up
|digarok
|pgz
|https://discord.com/channels/691915291721990194/1225481966200029286/1227075699895046235
|-
|soccur
|mutliplayer game of soccer
|beethead
|pgz
|executable:https://discord.com/channels/691915291721990194/1225481966200029286/1226808228948611184
source code:
https://discord.com/channels/691915291721990194/1225481966200029286/1226812472069980232
|-
|Trek
|port of classic Star Trek game
|contrerasd
|basic
|https://discord.com/channels/691915291721990194/1225481966200029286/1226727849944289341
|-
|Typing Star
|typing reaction game
|haydenkale
|pgz
|https://github.com/clandrew/typestar
|-
|}

== Game Jam #02 - October 25th-November 1st 2024 ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|Bach's MIDI Hero
|Free MIDI/PSG play + note play tutorial
|Mu0n
|pgz
the MIDI feature requires a F256K2 or F256Jr2; a legacy PSG option also allows F256K and F256Jr to still hear it. Optionally uses a MIDI in controller plugged in.
|https://github.com/Mu0n/F256KsimpleCdoodles/releases/download/v1.2/BachHero.pgz
|-
|f256_snake
|
|mgr42
|pgz. Use cursor keys, Atari joystick or SNES pad to play
|https://github.com/rmsk2/f256_snake
|-
|fnxsnake
|
|silk-neon
|pgz
|https://github.com/ksiondag/fnxsnake
|-
|The Hallow
|
|beethead
|pgz
|https://github.com/noyen1973/FoenixGameJamOct2024
|-
|Halloween Birthday
|
|SprySloth
|pgz
|https://github.com/cmassat/GameJam2024_F256K
|-
|Haunted Mansion
|
|digarok
|superbasic
|https://github.com/digarok/fnxgamejam-haunted-mansion
|-
|Kooyan
|
|Grenouye
|pgz
|https://github.com/dtremblay/kooyan.git
|-
|Spooky Run
|
|dwsJason
|pgz
|https://github.com/dwsJason/spooky
|-
|Trick or Treat
|
|Mike
|pgz
|https://github.com/mcassera/TrickOrTreat
|-
|Ultima III - Exodus
|port
|Minstrel Dragon
|pgz
|https://github.com/minstreldragon/F256_Ultima_3
|-
|Warlock
|remake of 68000 game
|xDraconian
|pgz
atari joystick
DOWN=change_level
UP=jump
UP-LEFT=leap
UP-RIGHT=leap
|https://github.com/scttgs0/Foenix_GameJam_Oct2024
|}

== Game Jam #03 - April 18th-April 27th 2025 ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|Arcade Shanghai v1.2
|Shanghai clone
|contrerasd
|basic, keep the .bas program in root, the rest in the provided ashanghai/ folder
|https://github.com/econtrerasd/ashanghai/releases
|-
|Bawk Bawk Cluck Cluck
|Chicken themed platformer
|beethead
|pgz
|https://github.com/noyen1973/FoenixGameJamApr2025
|-
|BitLadder
|Shoot 'Em Up
|Mu0n
|pgz. For full sound compatibility, a Jr2 or K2 is needed.
Uses 4 sound chips! (PSG, SID, OPL3, MIDI)
|https://mu0n.itch.io/bitladder
|-
|F256_Commando
|Commando port
|SprySloth
|pgz
|https://github.com/cmassat/F256_Commando
|-
|F256_LodeRunner
|Lode Runner port
|Minstrel Dragon
|pgz
|https://github.com/minstreldragon/F256_Loderunner/releases
|-
|Mahjong
|Shangai clone
|mgr42
|pgz
|https://github.com/rmsk2/f256_mahjong/releases
|-
|Quarth
|Block placement arcade game
|Grenouye
|pgz
|https://grenouye.itch.io/f256-quarth
|-
|Skee(ster)-Ball
|
|Mike
|pgz
|https://github.com/mcassera/skeeball256/tree/main
|}

== Game Jam #04 - November-December 2025 ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|Fallitaire
|A cozy fall-themed twist on Pyramid Solitaire, built for the Foenix F256K2 Game Jam!
|Programmer Vs World
|bas
|https://programmervsworld.itch.io/fallitaire
|-
|H.E.R.O.
|Port of the classic game H.E.R.O.
|Cibee
|pgz
|https://c1bee.itch.io/hero
|-
|Leaderboard
|Golf game
|xDraconian
|pgz
|https://discord.com/channels/691915291721990194/1424187774642290799/1456104940186501132
|-
|Pitfall
|Port of the classic Pitfall game from Activision
|MinstrelDragon
|pgz
|https://minstrel.itch.io/pitfall-foenix-f256x
|-
|Return of the Falcon
|
|Callisto
|TBD
|
|-
|Swicheroo
|An Alternate Puzzle Game
|jbaker8935
|pgz
|https://jbaker8935.itch.io/switcheroo
|-
|Track Day
|v1.0 top down race game vs computer controlled opponents
|MikeC
|pgz
|https://mcassera.itch.io/track-day-racing
|}

== Music ==

{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|cozyMIDI
|Plays a SMF with the SAM2695 or VS1053b
|Mu0n
|pgz
|cozyMIDI v2.7 can open and play type 0 and type 1 standard MIDI files (SMF)
needs a Jr2 or K2
with a 2x core at https://github.com/Mu0n/F256KsimpleCdoodles/tree/main/NoFussDemos

has a light show using all four RGB case LEDs of the K2 (might break compatibility with Jr2? test it please!)
run operation 1: just as itself, it will force you to pick a midi file in the 'midi/' folder /- cozymidi

run operation 2: in f/manager, if you put this as <code>midiplayer.pgz</code>in the '_apps/' folder, f/manager will open midi file with it when you launch .mid files.

Program link: https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/cozymidi.pgz
|-
|digestMidi
|converts .mid to .dim
|Mu0n
|pgz
|.mid files are slow to load, parse and prepare for a playback. This tool comes in to convert them into a .dim format that strips out unnecessary MIDI commands and sets it up for timer0 time delays. Works with type 0 and type 1 standard midi files. This tools does the conversion and lets you hear the result.
Find the latest version here: https://github.com/Mu0n/F256MiscGoodies/tree/main/apps
|-
|EdInHisLib
|SID+OPL3 simultaneously
|beethead, ported from xantax
|pgz
|F256 port: https://discordapp.com/channels/691915291721990194/1054249926521016392/1184413356598231120
original: <nowiki>https://csdb.dk/release/?id=170898</nowiki>. Not 100% accurate but close.
|-
|F256amp
|mp3, ogg, wav, wma file playback
|Mu0n
|pgz
|(aka audioplayer.pgz) v2.3 Needs a Jr.2 or K2 since it uses the VS1053b chip.
For a starter collection of .mp3 and other audio files, check the SD curated collection here: https://github.com/Mu0n/F256MiscGoodies/tree/main/SDCard_Collection
run operation 1: just as itself, it will force you to pick an audio file. it expects a <code>media/mp3/</code> folder, but it can live without it and peek into the root instead.

run operation 2: with an argument, it will auto-play it: /- f256amp yourmp3file.mp3

run operation 3: in f/manager, if you put this as <code>audioplayer.pgz</code> in the '_apps/' folder. This lets f/manager automatically open up .mp3, .wav, .ogg, .wma that you press enter on.

Program link: https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/f256amp.pgz
|-
|FireJam
|all chips, music playing with MIDI in
|Mu0n
|pgz
|v1.2 MIDI in and out capable, it will still partially work with a Jr. (PSG, and SID if you have them), a K (PSG, SID, OPL3) and the newest wave 2 Jr2 and K2 (PSG, SID, OPL3, SAM, VS1053b).
Best to use with a MIDI in controller, but it'll be controllable with arrows and space to make notes individually, or the F keys to start beats. https://github.com/Mu0n/F256KsimpleCdoodles/tree/main/NoFussDemos
|-
|jrtracker
|Tracker based in basic and uses the PSG
(considered obsolete, use tracker2)
|contrerasd
|basic
|https://ptb.discord.com/channels/691915291721990194/1008139105386889346/1188292876984143983
|-
|modo
|MOD player using the PSG
|dwsJason and digarok
|pgz
|https://discordapp.com/channels/691915291721990194/855689509520932885/1190723114661859429
|-
|Musik
|Music piece demo using MIDI
|Mike
|pgz
|https://github.com/mcassera/Musik/blob/main/Musik.PGZ<nowiki/>Musikalisches Würfelspiel
Requires a Jr2 or K2 since it uses MIDI
|-
|opl3snooper
|playback of VGM files (that use opl2 and opl3) and MIDI in
|Mu0n
|pgz
|v1.1 mainly plays back vgm files, but you can pause it and snoop around the channel instruments and play up to 18 note polyphony with MIDI in. expects a collection in media/vgm/, or it will browse from the root if it can't find.
It can load a .spl (Simple PLaylist) text file, which is one file per line, including their respective paths.
Requires a Jr2 or K2 with a 2x core to use the extra bank of SRAM.
For a starter collection of .vgm files, check the SD curated collection here: https://github.com/Mu0n/F256MiscGoodies/tree/main/SDCard_Collection
run operation 1: just as itself, it will force you to pick a midi file in the 'media/vgm/' folder

run operation 2: in f/manager (v1.1b9 and up), if you put this as <code>vgmplayer.pgz</code>in the '_apps/' folder, f/manager will open midi file with it when you launch .vgm files.

Program link: https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/opl3snooper.pgz
|-
|opl3tweak
|uses MIDI in, plays 18 channels polyphony in real time to the YMF262 OPL3. Fish for random register values.
|Mu0n
|pgz
|v0.1. Can't save or load instrument definitions yet. Needs a K2 with a MIDI in currently. https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/opl3tweak.pgz
Arrows to move around, + and - keys to incr/decr values or type in a hex value directly under the highlighted position.
|-
|piano
|Plays some PSG notes with the keyboard
|Mu0n
|basic
|https://github.com/Mu0n/F256KbasicBASICdoodles?tab=readme-ov-file#pulse-sound-generator-piano
|-
|playvgm
|plays a headless vgm file with OPL3
|G33kyAndIKnowIt
|pgx
|https://github.com/natebarney/playvgm-f256k
some example music files can be gotten from this post:
[https://discord.com/channels/691915291721990194/975117322836656138/1220366429640065074 https://discord.com/channels/6][https://discord.com/channels/691915291721990194/975117322836656138/1220366429640065074 91915291721990194/975117322836656138/1220366429640065074]

1) open a normal .vgm into a hex editor <nowiki/>and cut out the header bytes from 0x00 to 0x<nowiki/>FF

2) run by first using superbasic's '''''bload''''' '''''"yourmusicfile", $01000'''''
followed by running this program with '''''/- playvgm.pgx'''''
|-
|sidtweak
|uses MIDI in, plays 6 channels polyphony in real time to the dual SID. Fish for random register values.
|Mu0n
|pgz
|v0.1. Can't save or load instrument definitions yet. Needs a K2 with a MIDI in currently. https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/sidtweak.pgz
Arrows to move around, + and - keys to incr/decr values or type in a hex value directly under the highlighted position.
|-
|rawsidplayer
|plays raw PSID files from the HVSC collection, converted by zigreSID
|Mu0n
|pgz
|(formely psidplayer) v0.2 find rawsidplayer.pgz and a starter .rsd file (raw sid dumps). For a starter collection of .rsd files, check the SD curated collection here: https://github.com/Mu0n/F256MiscGoodies/tree/main/SDCard_Collection
extract sid.zip into a folder /sid/ in the root of your SD card, that's where psidplayer.pgz will first look to let you pick a file. failing that, it will fall back to the root folder and let you navigate.

program link:

https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/rawsidplayer.pgz
|-
|tracker2 v1.5
|Like jrtracker.bas, but using both PSGs
|contrerasd
|basic
|https://github.com/econtrerasd/Tracker2/releases
|}

== Uti<nowiki/>lities ==

{| class="wikitable"
|+
!Program
!Descrip<nowiki/>tion
!Author
!Notes on running
!Link
|-
|basic2text
|A simple utility for translating Commodore BASIC (all variants) from its native tokenized file format to a text format that can be opened with SuperBASIC. Does not perform any code translation: all adaptation is up to you.
|Micah
|pgZ
|https://github.com/WartyMN/F256-BasText/releases/latest
|
|-
|dcopy
|A tool to copy files from one drive to another or to/from your PC via RS-232 and a nullmodem cable
|mgr42
|pgz/flash
|https://github.com/rmsk2/f256_dcopy
|
|-
|f/manager
|A general file utility, launcher, and memory viewing program. Dual-panel file/memory browsers; copy between disks, between folders on same disk, and from memory to disk and vice versa; delete, rename, and duplicate files; view files as hex or text (with word-wrap); launch applications and known file types; set the RTC clock; search in RAM and flash. Works with internal SD card and IEC devices such as FNX1591 and Commodore 1541. Can be installed in primary flash position ahead of SuperBASIC or DOS, or at a higher location. Can also be run from disk with "- fm.pgz".
|Micah
|pgZ/flash
|https://github.com/WartyMN/F256-FileManager/releases
|
|-
|f256_reset
|A small utility that lets you reset the machine through this piece of flash software
|mgr42
|flash
|https://github.com/rmsk2/f256_reset
|
|-
|fcart
|A program that allows to write data to flash expansion cartridges
|mgr42
|pgz, on-board and cartridge flash
|https://github.com/rmsk2/cartflash
|
|-
|flashcart
|Allows to wipe a block of flash or write a program to a flash cart, from this basic program from the F256Jr/K
|redfool.
|basic
|https://github.com/Red-Fool/F256_FlashCart/tree/main
|
|-
|flashselect
|Allows to select a program to start from a flash cartridge via a menu
|mgr42
|pgz, on-board and cartridge flash
|https://github.com/rmsk2/flashselect
|
|-
|fonts
|A variety of fonts using the standard F256 character set arrangement. Load with the F256 file manager (f/manager), or your own code.
|Micah
|(not a program)
|[https://github.com/WartyMN/Foenix-Fonts/tree/main https://github.com/WartyMN/Foenix-Fonts]
|
|-
|midiStuff
|Test program for a F256K2 or F256Jr2 that sends MIDI data to the internal sam2695 dream chip that produces MIDI based audio. Also test a keyboard controller plugged in the MIDI in port.
|Mu0n
|pgz
|https://github.com/Mu0n/F256KsimpleCdoodles/blob/main/README.md#midistuff
|
|-
|moreorless
|A text editor for the Foenix 256 line of computers
|mgr42
|pgz
|https://github.com/rmsk2/moreorless/releases/
|
|-
|pgz2flash
|A program for your Linux, Windows or MacOS machine to turn any PGZ or SuperBASIC program into a KUP which can be run from cartridge or onboard flash memory
|mgr42
|Executable for modern computers
|https://github.com/rmsk2/pgz2flash
|
|-
|sidTester
|Simple superbasic program that tests out all 3 voices of the SID1 on the Jr (if populated), K, Jr2 and K2. Ported by Mu0n, made by andy on HackJunk.com https://hackjunk.com/2017/11/07/commodore-64-sid-tester/
|andy
|basic
|https://github.com/Mu0n/F256MiscGoodies/blob/main/apps/sidtester.bas
|
|-
|testsuite.bas
|a series of tests for your F256, video modes and sound chips
|econtrerasd
|basic
|run from the root,
https://github.com/econtrerasd/testSuite-F256/releases
|
|-
|wget<nowiki/>
|<nowiki/>fetches a file from a http address if you have a network connection active. Works with the K and Jr. ESP32 Feather 'huzzah' board. Not meant to be used with the K2 and Jr2 Wiznet chip.
|gadget
|<nowiki/>pgz/flash
|https://github.com/ghackwrench/F256_wget
|
|}

== Sample Code ==

{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|Assembly examples
|Sample programs for several features of the Foenix F256K and Jr.
|mgr42
|read github
|https://github.com/rmsk2/Hello_Foenix256_Jr/blob/main/testprogs.md
|-
|cc65 example
|c example code
|gadget
|read github
|https://github.com/ghackwrench/F256_Jr_Kernel_DOS
|-
|digarok basic stuff
|Lots of basic examples
|digarok
|read github
|https://github.com/digarok/superbasic-traveler/tree/main
|-
|MikeC repos
|Various projects in assembly
|MikeC
|read github
|https://github.com/mcassera
|-
|Mu0n's F256K asm doodles
|Some asm examples
|Mu0n
|read github
|https://github.com/Mu0n/F256KsimpleASMdoodles
|-
|Mu0n's F256K basic doodles
|Some basic examples
|Mu0n
|read github
|https://github.com/Mu0n/F256KbasicBASICdoodles
|-
|Mu0n's F256K C doodles
|Some C examples
|Mu0n
|read github
|https://github.com/Mu0n/F256KsimpleCdoodles
|-
|Raúl SQ basic repo
|F256 SuperBASIC Trigonometry
|Raúl SQ
|basic
|https://github.com/raul-sq/FoenixF256K2
|-
|tcp example
|connects to a server and gets typed in text echoed back to you
|gadget
|$2000
|https://github.com/ghackwrench/F256_example_tcp
|}

Software for 6502

2026-01-31T21:39:42Z

1BitFeverDreams: /* Music */ cozymidi v2.7

Note that when an hex address is given, it's meant to instruct as to which address to bload or to send (ie foenixmgr python script) the program (ie a .bin file) to before running it. For extra help on how to run .bin files and almost every possible scheme that has to be used to run program, you can consult this video that's also part of [[Getting Started]], this one: https://www.youtube.com/watch?v=0ShFv89KGDs

Many download links are posts in the main [https://discord.gg/9vjUEGgcUS Foenix Retro Systems discord server] which will require you to join in order to get to them.

A [[Getting Started#Demos Archive|Demo Archive]] was put together in September 2023 to get ready to show to youtubers, some of these are linked once more, in this page.

There's also the Foenix Marketplace website maintained by EMWhite with its own collection of articles and software http://apps.emwhite.org/foenixmarketplace/.

===== Curated SD card collection of games, demos, utilities =====
Here is a download link to a zip file meant to be extracted into the root of an SD card: https://github.com/Mu0n/F256MiscGoodies/tree/main/SDCard_Collection

Best to wipe out your SD card and start anew with the contents of this extracted to root. Micah's file manager doesn't like long lists of files so it really is best to not overdo it. I tried to minimize the files in root, but I couldn't for everything.

Open the readme.txt file with moreorless to see some instructions about the collection. Best to run /- fm first, then open the readme.txt from it

== Applications ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|F256 f/term
|Terminal emulator for F256K and Jr with classic (flat) memory load
|Micah
| - fterm.pgZ or use f/manager
|https://github.com/WartyMN/F256-terminal/blob/main/release/fterm.pgZ
|-
|FoenixTarot
|Tarot card readings in SuperBasic
|Mike
|basic
|https://github.com/mcassera/FoenixTarot/tree/main
|-
|Forthf256
|Forth implementation
|Vasyl
|pgz in its forth/ folder
|https://github.com/VasylTsv/ForthX16
|-
|WildBits Graphic Toolkit
|(fmr. F256-GraphicToolkit) Sprite editor, Tilemap editor, Font editor + misc tools
|econtrerasd
|basic
|https://github.com/econtrerasd/F256-GraphicToolkit/releases
|}

== Demos ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|badapple
|A 80x60 textmode port of Bad Apple, uses the VS1053b for quality mp3 audio. Needs a Jr2 or K2!
|Mu0n
|pgz*
|*unzip badapple.zip into the root of your SD card. If done right, the 3 files within will be in the demos/ folder. The program expects its data file there when it runs. https://github.com/Mu0n/F256MiscGoodies/blob/main/apps/badapple.zip
|-
|balls
|Draw a good quantity of multiplexed sprites, fast. Balls bouncing around
|celton
|pgz
|https://github.com/FoenixRetro/demos/blob/main/MultiplexedSprites.md
|-
|F256Archon
|Splash screen intro, plays MIDI using the SAM2695, requires a K2 or Jr2
|Mu0n
|pgz
|https://github.com/Mu0n/F256Archon/releases
|-
|f256_life
|An implementation of Conway's game of life
|mgr42
|pgz
|https://github.com/rmsk2/f256_life
|-
|F256 Mandelbrot
|Draws Mandelbrot set fast (5 mins) using coprocessor math. Allows to zoom into the set.
|mgr42
|uses basic loader
|https://github.com/rmsk2/F256_Mandelbrot
|-
|F256ShowCase
|Shows sliding tiling graphics, moves with joystick
|eriktier
|$0000
|https://github.com/pig-games/F256Showcase
|-
|fnxmas23
|PSG mod music, scrolling text, sound effects, must see demo!
|dwsJason and digarok
|pgz
|https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/apps/xmas24_k2.pgz revised version that can run on wave 2 Jr2 and K2 as well
|-
|foenixmas23
|Xmas 2023 demo with SID music from the classic 1983 C64 xmas demo
|EMWhite
|uses basic loader
|http://apps.emwhite.org/shared-files/815/?foenixmas23.zip
|-
|livingworlds
|Living Worlds, a port of a color cycling by Mark Ferrari, ported here on the F256 by haydenkale
|haydenkale
|$0000
|https://github.com/clandrew/livingworlds/tree/e4532e0d530b76ccb90368fdf5ad10bfa2deeb12
|-
|mandel
|Will draw a mandelbrot set in 3 hours, more useful as a stability test than a useful fractal program
|Mu0n
|basic
|https://github.com/Mu0n/F256KbasicBASICdoodles?tab=readme-ov-file#fractal
|-
|mariobros
|Tilemap and platformer test based on Mario Bros. (1983)
|beethead
|pgz
|https://github.com/noyen1973/mariobros
|-
|pendulum
|Sprite and MIDI demo
|MikeC
|pgz
|https://github.com/mcassera/pendulum
|-
|wormhole
|Shows a fast wireframe animation of a wormhole
|haydenkale
|pgz or bin at $0000
|https://github.com/clandrew/wormhole?tab=readme-ov-file
|}

== Games ==

{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|bbombers
|Boulder Bombers (Alpha-2) Clone of Canyon Bombers
|Scott (xDraconian)
|pgx
atari joystick
|https://github.com/scttgs0/BoulderBombers<nowiki/>https://github.com/scttgs0/BoulderBombers/releases/tag/alpha_2
|-
|Bombsweeper
|Bomb sweeper port
|beethead
|pgz
|https://discord.com/channels/691915291721990194/855689509520932885/1196352934083035156
|-
|Cosmic
|Shoot 'em up
|beethead
|pgz
|https://discordapp.com/channels/691915291721990194/1054250238308790342/1175982979537969214
|-
|F256-Trek
|Updated Trek, with modern F256 Graphics
|econtrerasd
|basic
|[https://github.com/econtrerasd/Trek-F256/releases/tag/v1.0 https://github.com/econtrerasd/Trek-F256/releases]
|-
|F256 two to the power of eleven
|Port of the puzzle game of 2048
|mgr42
|pgz
|https://github.com/rmsk2/F256_2048<nowiki/>
|-
|fillerup
|Fill 'er Up (WIP)
Qix-like game
|Scott (xDraconian)
|pgx
atari joystick
|https://github.com/scttgs0/Fill-er-up
|-
|FusionDrive
|An outrun type game that also plays a MIDI soundtrack
|Mu0n
|pgz
|wip v0.2, can use a NES pad #1 to move around, or left/right arrow keys currently https://github.com/Mu0n/F256KsimpleCdoodles/tree/main/NoFussDemos
|-
|jewelkeeper
|Sokoban port
|beethead
|pgz
|https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/apps/jewelkeeper.pgz<nowiki/>You can now specify a level file when loading the game <code>/- jewelkeeper.pgz <levels.txt></code>. Find more levels at https://www.sourcecode.se/sokoban/levels.php. Keep in mind the maximum level dimension is 20x15, anything larger will be ignored
|-
|Jr Wördl
|port of Wordle
|AgeAgeEye
|basic
|https://github.com/ageageeye/Superbasic-F256Jr-examples
|-
|kartdemo
|Kart racing game
|SprySloth
|pgz
|https://discord.com/channels/691915291721990194/1225217654487253094/1228246780840513556
|-
|Lair of the Lich King
|Rogue like dungeon crawler. Demo has 3 levels; full has 25+
|Micah
| - lkdemo/lk.pgz
|[https://discord.com/channels/691915291721990194/1230670413361844244/1317256215566487593 1.0 Beta 19 Demo]
|-
|livewire
|Livewire (WIP)
Tempest-like game
|Scott (xDraconian)
|pgx
atari joystick
|https://github.com/scttgs0/Livewire
|-
|Maze-Munch
|Pac-Man clone
|SprySloth
|pgz
|https://github.com/cmassat/Maze-Munch
|-
|pdefense
|Planetary Defense (WIP)
|Scott (xDraconian)
|pgx
mouse
atari joystick
|https://github.com/scttgs0/PlanetaryDefense
|-
|Shanghai/Mahjongg
|A clone of Shanghai. Also known as Mahjongg
|mgr42
|pgz or KUP
mouse needed
|https://github.com/rmsk2/f256_mahjong
|-
|Ski-Jr
|Ski game downhill
|digarok
|basic
|https://github.com/digarok/superbasic-traveler/blob/main/ski-jr.bas
|-
|Track & Field
|Olympic Game by Konami (WIP)
|Scott (xDraconian)
|pgz
atari joystick or keyboard
|
|-
|Tetris
|Good old 80's game
|Daniel Tremblay (Grenouye)
|pgz
atari joystick or keyboard
|https://github.com/dtremblay/c256-tetris/tree/f256k
|}

== Game Jam #01 - April 6th/7th 2024 ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|15puzzle
|Number sort puzzle
|mgr42
|pgz
|https://github.com/rmsk2/f256_15puzzle/releases<nowiki/>
|-
|Flight Simulator
|flying simulator
|sduensin
|pgz
|https://cdn.discordapp.com/attachments/1225481966200029286/1227764847819620454/shotel.pgz
|-
|frisbee
|Frisbee throw past sport game
|dwsJason
|pgz
|https://github.com/dwsJason/f256/blob/develop/merlin32/frisbee/frisbee.pgz
|-
|Impasse
|Shoot 'em up
|digarok
|pgz
|https://discord.com/channels/691915291721990194/1225481966200029286/1227075699895046235
|-
|soccur
|mutliplayer game of soccer
|beethead
|pgz
|executable:https://discord.com/channels/691915291721990194/1225481966200029286/1226808228948611184
source code:
https://discord.com/channels/691915291721990194/1225481966200029286/1226812472069980232
|-
|Trek
|port of classic Star Trek game
|contrerasd
|basic
|https://discord.com/channels/691915291721990194/1225481966200029286/1226727849944289341
|-
|Typing Star
|typing reaction game
|haydenkale
|pgz
|https://github.com/clandrew/typestar
|-
|}

== Game Jam #02 - October 25th-November 1st 2024 ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|Bach's MIDI Hero
|Free MIDI/PSG play + note play tutorial
|Mu0n
|pgz
the MIDI feature requires a F256K2 or F256Jr2; a legacy PSG option also allows F256K and F256Jr to still hear it. Optionally uses a MIDI in controller plugged in.
|https://github.com/Mu0n/F256KsimpleCdoodles/releases/download/v1.2/BachHero.pgz
|-
|f256_snake
|
|mgr42
|pgz. Use cursor keys, Atari joystick or SNES pad to play
|https://github.com/rmsk2/f256_snake
|-
|fnxsnake
|
|silk-neon
|pgz
|https://github.com/ksiondag/fnxsnake
|-
|The Hallow
|
|beethead
|pgz
|https://github.com/noyen1973/FoenixGameJamOct2024
|-
|Halloween Birthday
|
|SprySloth
|pgz
|https://github.com/cmassat/GameJam2024_F256K
|-
|Haunted Mansion
|
|digarok
|superbasic
|https://github.com/digarok/fnxgamejam-haunted-mansion
|-
|Kooyan
|
|Grenouye
|pgz
|https://github.com/dtremblay/kooyan.git
|-
|Spooky Run
|
|dwsJason
|pgz
|https://github.com/dwsJason/spooky
|-
|Trick or Treat
|
|Mike
|pgz
|https://github.com/mcassera/TrickOrTreat
|-
|Ultima III - Exodus
|port
|Minstrel Dragon
|pgz
|https://github.com/minstreldragon/F256_Ultima_3
|-
|Warlock
|remake of 68000 game
|xDraconian
|pgz
atari joystick
DOWN=change_level
UP=jump
UP-LEFT=leap
UP-RIGHT=leap
|https://github.com/scttgs0/Foenix_GameJam_Oct2024
|}

== Game Jam #03 - April 18th-April 27th 2025 ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|Arcade Shanghai v1.2
|Shanghai clone
|contrerasd
|basic, keep the .bas program in root, the rest in the provided ashanghai/ folder
|https://github.com/econtrerasd/ashanghai/releases
|-
|Bawk Bawk Cluck Cluck
|Chicken themed platformer
|beethead
|pgz
|https://github.com/noyen1973/FoenixGameJamApr2025
|-
|BitLadder
|Shoot 'Em Up
|Mu0n
|pgz. For full sound compatibility, a Jr2 or K2 is needed.
Uses 4 sound chips! (PSG, SID, OPL3, MIDI)
|https://mu0n.itch.io/bitladder
|-
|F256_Commando
|Commando port
|SprySloth
|pgz
|https://github.com/cmassat/F256_Commando
|-
|F256_LodeRunner
|Lode Runner port
|Minstrel Dragon
|pgz
|https://github.com/minstreldragon/F256_Loderunner/releases
|-
|Mahjong
|Shangai clone
|mgr42
|pgz
|https://github.com/rmsk2/f256_mahjong/releases
|-
|Quarth
|Block placement arcade game
|Grenouye
|pgz
|https://grenouye.itch.io/f256-quarth
|-
|Skee(ster)-Ball
|
|Mike
|pgz
|https://github.com/mcassera/skeeball256/tree/main
|}

== Game Jam #04 - November-December 2025 ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|Fallitaire
|A cozy fall-themed twist on Pyramid Solitaire, built for the Foenix F256K2 Game Jam!
|Programmer Vs World
|bas
|https://programmervsworld.itch.io/fallitaire
|-
|H.E.R.O.
|Port of the classic game H.E.R.O.
|Cibee
|pgz
|https://c1bee.itch.io/hero
|-
|Leaderboard
|Golf game
|xDraconian
|pgz
|https://discord.com/channels/691915291721990194/1424187774642290799/1456104940186501132
|-
|Pitfall
|Port of the classic Pitfall game from Activision
|MinstrelDragon
|pgz
|https://minstrel.itch.io/pitfall-foenix-f256x
|-
|Return of the Falcon
|
|Callisto
|TBD
|
|-
|Swicheroo
|An Alternate Puzzle Game
|jbaker8935
|pgz
|https://jbaker8935.itch.io/switcheroo
|-
|Track Day
|v1.0 top down race game vs computer controlled opponents
|MikeC
|pgz
|https://mcassera.itch.io/track-day-racing
|}

== Music ==

{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|cozyMIDI
|Plays a SMF with the SAM2695 or VS1053b
|Mu0n
|pgz
|cozyMIDI v2.7 can open and play type 0 and type 1 standard MIDI files (SMF)
needs a Jr2 or K2
with a 2x core at https://github.com/Mu0n/F256KsimpleCdoodles/tree/main/NoFussDemos

run operation 1: just as itself, it will force you to pick a midi file in the 'midi/' folder /- cozymidi

run operation 2: in f/manager, if you put this as <code>midiplayer.pgz</code>in the '_apps/' folder, f/manager will open midi file with it when you launch .mid files.

Program link: https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/cozymidi.pgz
|-
|digestMidi
|converts .mid to .dim
|Mu0n
|pgz
|.mid files are slow to load, parse and prepare for a playback. This tool comes in to convert them into a .dim format that strips out unnecessary MIDI commands and sets it up for timer0 time delays. Works with type 0 and type 1 standard midi files. This tools does the conversion and lets you hear the result.
Find the latest version here: https://github.com/Mu0n/F256MiscGoodies/tree/main/apps
|-
|EdInHisLib
|SID+OPL3 simultaneously
|beethead, ported from xantax
|pgz
|F256 port: https://discordapp.com/channels/691915291721990194/1054249926521016392/1184413356598231120
original: <nowiki>https://csdb.dk/release/?id=170898</nowiki>. Not 100% accurate but close.
|-
|F256amp
|mp3, ogg, wav, wma file playback
|Mu0n
|pgz
|(aka audioplayer.pgz) v2.3 Needs a Jr.2 or K2 since it uses the VS1053b chip.
For a starter collection of .mp3 and other audio files, check the SD curated collection here: https://github.com/Mu0n/F256MiscGoodies/tree/main/SDCard_Collection
run operation 1: just as itself, it will force you to pick an audio file. it expects a <code>media/mp3/</code> folder, but it can live without it and peek into the root instead.

run operation 2: with an argument, it will auto-play it: /- f256amp yourmp3file.mp3

run operation 3: in f/manager, if you put this as <code>audioplayer.pgz</code> in the '_apps/' folder. This lets f/manager automatically open up .mp3, .wav, .ogg, .wma that you press enter on.

Program link: https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/f256amp.pgz
|-
|FireJam
|all chips, music playing with MIDI in
|Mu0n
|pgz
|v1.2 MIDI in and out capable, it will still partially work with a Jr. (PSG, and SID if you have them), a K (PSG, SID, OPL3) and the newest wave 2 Jr2 and K2 (PSG, SID, OPL3, SAM, VS1053b).
Best to use with a MIDI in controller, but it'll be controllable with arrows and space to make notes individually, or the F keys to start beats. https://github.com/Mu0n/F256KsimpleCdoodles/tree/main/NoFussDemos
|-
|jrtracker
|Tracker based in basic and uses the PSG
(considered obsolete, use tracker2)
|contrerasd
|basic
|https://ptb.discord.com/channels/691915291721990194/1008139105386889346/1188292876984143983
|-
|modo
|MOD player using the PSG
|dwsJason and digarok
|pgz
|https://discordapp.com/channels/691915291721990194/855689509520932885/1190723114661859429
|-
|Musik
|Music piece demo using MIDI
|Mike
|pgz
|https://github.com/mcassera/Musik/blob/main/Musik.PGZ<nowiki/>Musikalisches Würfelspiel
Requires a Jr2 or K2 since it uses MIDI
|-
|opl3snooper
|playback of VGM files (that use opl2 and opl3) and MIDI in
|Mu0n
|pgz
|v1.1 mainly plays back vgm files, but you can pause it and snoop around the channel instruments and play up to 18 note polyphony with MIDI in. expects a collection in media/vgm/, or it will browse from the root if it can't find.
It can load a .spl (Simple PLaylist) text file, which is one file per line, including their respective paths.
Requires a Jr2 or K2 with a 2x core to use the extra bank of SRAM.
For a starter collection of .vgm files, check the SD curated collection here: https://github.com/Mu0n/F256MiscGoodies/tree/main/SDCard_Collection
run operation 1: just as itself, it will force you to pick a midi file in the 'media/vgm/' folder

run operation 2: in f/manager (v1.1b9 and up), if you put this as <code>vgmplayer.pgz</code>in the '_apps/' folder, f/manager will open midi file with it when you launch .vgm files.

Program link: https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/opl3snooper.pgz
|-
|opl3tweak
|uses MIDI in, plays 18 channels polyphony in real time to the YMF262 OPL3. Fish for random register values.
|Mu0n
|pgz
|v0.1. Can't save or load instrument definitions yet. Needs a K2 with a MIDI in currently. https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/opl3tweak.pgz
Arrows to move around, + and - keys to incr/decr values or type in a hex value directly under the highlighted position.
|-
|piano
|Plays some PSG notes with the keyboard
|Mu0n
|basic
|https://github.com/Mu0n/F256KbasicBASICdoodles?tab=readme-ov-file#pulse-sound-generator-piano
|-
|playvgm
|plays a headless vgm file with OPL3
|G33kyAndIKnowIt
|pgx
|https://github.com/natebarney/playvgm-f256k
some example music files can be gotten from this post:
[https://discord.com/channels/691915291721990194/975117322836656138/1220366429640065074 https://discord.com/channels/6][https://discord.com/channels/691915291721990194/975117322836656138/1220366429640065074 91915291721990194/975117322836656138/1220366429640065074]

1) open a normal .vgm into a hex editor <nowiki/>and cut out the header bytes from 0x00 to 0x<nowiki/>FF

2) run by first using superbasic's '''''bload''''' '''''"yourmusicfile", $01000'''''
followed by running this program with '''''/- playvgm.pgx'''''
|-
|sidtweak
|uses MIDI in, plays 6 channels polyphony in real time to the dual SID. Fish for random register values.
|Mu0n
|pgz
|v0.1. Can't save or load instrument definitions yet. Needs a K2 with a MIDI in currently. https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/sidtweak.pgz
Arrows to move around, + and - keys to incr/decr values or type in a hex value directly under the highlighted position.
|-
|rawsidplayer
|plays raw PSID files from the HVSC collection, converted by zigreSID
|Mu0n
|pgz
|(formely psidplayer) v0.2 find rawsidplayer.pgz and a starter .rsd file (raw sid dumps). For a starter collection of .rsd files, check the SD curated collection here: https://github.com/Mu0n/F256MiscGoodies/tree/main/SDCard_Collection
extract sid.zip into a folder /sid/ in the root of your SD card, that's where psidplayer.pgz will first look to let you pick a file. failing that, it will fall back to the root folder and let you navigate.

program link:

https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/rawsidplayer.pgz
|-
|tracker2 v1.5
|Like jrtracker.bas, but using both PSGs
|contrerasd
|basic
|https://github.com/econtrerasd/Tracker2/releases
|}

== Uti<nowiki/>lities ==

{| class="wikitable"
|+
!Program
!Descrip<nowiki/>tion
!Author
!Notes on running
!Link
|-
|basic2text
|A simple utility for translating Commodore BASIC (all variants) from its native tokenized file format to a text format that can be opened with SuperBASIC. Does not perform any code translation: all adaptation is up to you.
|Micah
|pgZ
|https://github.com/WartyMN/F256-BasText/releases/latest
|
|-
|dcopy
|A tool to copy files from one drive to another or to/from your PC via RS-232 and a nullmodem cable
|mgr42
|pgz/flash
|https://github.com/rmsk2/f256_dcopy
|
|-
|f/manager
|A general file utility, launcher, and memory viewing program. Dual-panel file/memory browsers; copy between disks, between folders on same disk, and from memory to disk and vice versa; delete, rename, and duplicate files; view files as hex or text (with word-wrap); launch applications and known file types; set the RTC clock; search in RAM and flash. Works with internal SD card and IEC devices such as FNX1591 and Commodore 1541. Can be installed in primary flash position ahead of SuperBASIC or DOS, or at a higher location. Can also be run from disk with "- fm.pgz".
|Micah
|pgZ/flash
|https://github.com/WartyMN/F256-FileManager/releases
|
|-
|f256_reset
|A small utility that lets you reset the machine through this piece of flash software
|mgr42
|flash
|https://github.com/rmsk2/f256_reset
|
|-
|fcart
|A program that allows to write data to flash expansion cartridges
|mgr42
|pgz, on-board and cartridge flash
|https://github.com/rmsk2/cartflash
|
|-
|flashcart
|Allows to wipe a block of flash or write a program to a flash cart, from this basic program from the F256Jr/K
|redfool.
|basic
|https://github.com/Red-Fool/F256_FlashCart/tree/main
|
|-
|flashselect
|Allows to select a program to start from a flash cartridge via a menu
|mgr42
|pgz, on-board and cartridge flash
|https://github.com/rmsk2/flashselect
|
|-
|fonts
|A variety of fonts using the standard F256 character set arrangement. Load with the F256 file manager (f/manager), or your own code.
|Micah
|(not a program)
|[https://github.com/WartyMN/Foenix-Fonts/tree/main https://github.com/WartyMN/Foenix-Fonts]
|
|-
|midiStuff
|Test program for a F256K2 or F256Jr2 that sends MIDI data to the internal sam2695 dream chip that produces MIDI based audio. Also test a keyboard controller plugged in the MIDI in port.
|Mu0n
|pgz
|https://github.com/Mu0n/F256KsimpleCdoodles/blob/main/README.md#midistuff
|
|-
|moreorless
|A text editor for the Foenix 256 line of computers
|mgr42
|pgz
|https://github.com/rmsk2/moreorless/releases/
|
|-
|pgz2flash
|A program for your Linux, Windows or MacOS machine to turn any PGZ or SuperBASIC program into a KUP which can be run from cartridge or onboard flash memory
|mgr42
|Executable for modern computers
|https://github.com/rmsk2/pgz2flash
|
|-
|sidTester
|Simple superbasic program that tests out all 3 voices of the SID1 on the Jr (if populated), K, Jr2 and K2. Ported by Mu0n, made by andy on HackJunk.com https://hackjunk.com/2017/11/07/commodore-64-sid-tester/
|andy
|basic
|https://github.com/Mu0n/F256MiscGoodies/blob/main/apps/sidtester.bas
|
|-
|testsuite.bas
|a series of tests for your F256, video modes and sound chips
|econtrerasd
|basic
|run from the root,
https://github.com/econtrerasd/testSuite-F256/releases
|
|-
|wget<nowiki/>
|<nowiki/>fetches a file from a http address if you have a network connection active. Works with the K and Jr. ESP32 Feather 'huzzah' board. Not meant to be used with the K2 and Jr2 Wiznet chip.
|gadget
|<nowiki/>pgz/flash
|https://github.com/ghackwrench/F256_wget
|
|}

== Sample Code ==

{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|Assembly examples
|Sample programs for several features of the Foenix F256K and Jr.
|mgr42
|read github
|https://github.com/rmsk2/Hello_Foenix256_Jr/blob/main/testprogs.md
|-
|cc65 example
|c example code
|gadget
|read github
|https://github.com/ghackwrench/F256_Jr_Kernel_DOS
|-
|digarok basic stuff
|Lots of basic examples
|digarok
|read github
|https://github.com/digarok/superbasic-traveler/tree/main
|-
|MikeC repos
|Various projects in assembly
|MikeC
|read github
|https://github.com/mcassera
|-
|Mu0n's F256K asm doodles
|Some asm examples
|Mu0n
|read github
|https://github.com/Mu0n/F256KsimpleASMdoodles
|-
|Mu0n's F256K basic doodles
|Some basic examples
|Mu0n
|read github
|https://github.com/Mu0n/F256KbasicBASICdoodles
|-
|Mu0n's F256K C doodles
|Some C examples
|Mu0n
|read github
|https://github.com/Mu0n/F256KsimpleCdoodles
|-
|Raúl SQ basic repo
|F256 SuperBASIC Trigonometry
|Raúl SQ
|basic
|https://github.com/raul-sq/FoenixF256K2
|-
|tcp example
|connects to a server and gets typed in text echoed back to you
|gadget
|$2000
|https://github.com/ghackwrench/F256_example_tcp
|}

Glossary

2026-01-27T17:17:29Z

1BitFeverDreams: various changes to add the Wildbits keyword in relevant places

= Wildbits / Foenix F256 Glossary =

{{Short description|Reference guide to F256 hardware, software, and technical terminology}}

A comprehensive glossary of terms, acronyms, and concepts from the F256 ecosystem.

__TOC__

== Computer Models ==

; F256Jr
: First-generation "Junior" model featuring WDC 65C02 CPU, 512KB SRAM, Cyclone IV FPGA, and [[TinyVicky]] graphics.

; F256Jr2 (Jr.Jr.)
: Second-generation Junior model with WDC 65C816 CPU, 2MB SRAM, Artix 7 FPGA, and TinyVicky II graphics. See [[Product_Specifications]].

; F256K
: First-generation keyboard-integrated model with same specs as F256Jr plus built-in mechanical keyboard.

; F256K2
: Second-generation keyboard model with 65816, 2MB SRAM, 128MB DDR3 DRAM, Artix 7 XC7A200T FPGA, and Vicky "The Fourth" graphics.

; Foenix Retro Systems
: Brand name for the retro computer line created by Stefany Allaire.

;Wildbits/Jr2
: New name for the SBC formerly known as the F256Jr2. Second-generation Junior model with WDC 65C816 CPU, 2MB SRAM, Artix 7 FPGA, and TinyVicky II graphics. See [[Product_Specifications]].

;Wildbits/K2
: New name for the keyboard model formerly known as the F256K2. Second-generation keyboard model with 65816, 2MB SRAM, 128MB DDR3 DRAM, Artix 7 XC7A200T FPGA, and Vicky "The Fourth" graphics.

; Wildbits Computing Company
: New owner of the computer line formerly known as F256. Now branded as Wildbits/K2, Wildbits/Jr2

== Processors ==

; 6502
: Classic 8-bit CPU from MOS Technology (1975), the foundation architecture for the F256/Wildbits series.

; WDC 65C02
: Western Design Center's CMOS version of the 6502 with lower power consumption and additional instructions. Default CPU in first-gen F256 models.

; WDC 65C816 (65816)
: 16-bit upgrade to the 65C02 with 24-bit addressing (up to 16MB) and selectable 8/16-bit registers. See [[65816_Overview]].

; FNX6809
: FPGA-based implementation of the Motorola 6809 CPU that can ran on first gen F256 hardware as an addon DIP PCB board. See [[FNX6809_Overview]].

;6809
: FPGA-based implementation of the Motorola 6809 CPU that can run on second gen F256/Wildbits hardware. See [[FNX6809_Overview]].

; Emulation Mode
: Default 65816 startup mode that behaves like a 65C02 for backwards compatibility.

; Native Mode
: 65816 mode enabling 16-bit registers, movable direct page, and full 24-bit addressing.

; Rockwell Instructions
: Extended 6502 instructions (BBS, BBR, RMB, SMB) supported by 65C02 but '''NOT''' by 65816. Avoid these for 65816 compatibility.

== FPGA & Hardware ==

; FPGA
: Field-Programmable Gate Array; reconfigurable chip implementing the F256/Wildbits's custom logic, graphics, and sound.

; Cyclone IV (EP4CE15)
: Intel/Altera FPGA used in first-gen F256 models (15,408 logic elements, 504kb BRAM).

; Artix 7 (XC7A35T)
: Xilinx FPGA used in F256Jr2 or Wildbits/Jr2 (33,280 logic cells, 1,800kb BRAM).

; Artix 7 (XC7A200T)
: Larger Xilinx FPGA used in F256K2 or Wildbits/K2 (215,360 logic cells, 13,140kb BRAM).

; Core
: FPGA configuration/bitstream that defines the computer's behavior. See [[FPGA_Releases]].

; Core2x
: Enhanced FPGA core with 2× CPU speed (12MHz), 24-bit flat addressing, 64 additional sprites, and hardware line drawing.

; JTAG
: Joint Test Action Group; interface for programming the FPGA on first-gen models.

; USB Blaster
: Hardware programmer used to flash FPGA via JTAG on F256Jr and F256K.

; RP2040
: Raspberry Pi microcontroller that initializes the FPGA and uploads cores on second-gen models.

; Context (CNTX)
: On F256K2 and Wildbits/K2, one of four FPGA core slots (CNTX1-CNTX4) selectable via [[DIP_switches]].

; Sii9022
: HDMI encoder chip used on black F256K2 boards; removed in purple F256K2 and Wildbits/K2 boards where HDMI encoding moved to FPGA.

== Graphics ==

; TinyVicky
: Graphics subsystem in first-gen F256 models (F256Jr, F256K).

; TinyVicky II
: Enhanced graphics subsystem in F256Jr2 and Wildbits/Jr2.

; Vicky "The Fourth"
: Advanced graphics subsystem in F256K2 and Wildbits/K2.

; VICKY
: General name for the Foenix and Wildbits graphics/video controller family.

; Bitmap
: Graphics layer displaying pixel-mapped images directly from SRAM. Up to 3 bitmap layers available.

; Tilemap
: Graphics layer displaying tiles from tilesets for efficient scrolling graphics. Up to 3 tilemap layers available.

; Tileset
: Collection of tile graphics (8×8 or 16×16 pixels) referenced by tilemaps. Up to 8 tilesets supported.

; Sprite
: Hardware-accelerated moveable graphic object. Sizes: 8×8, 16×16, 24×24, or 32×32 pixels. 64 sprites standard, 128 with Core2x.

; CLUT
: Color Look-Up Table; palette mapping 8-bit index values to BGR colors. 4 graphics CLUTs available.

; Gamma Correction
: Color brightness adjustment via lookup tables at $C000-$C8FF in IO Page 0.

; DMA
: Direct Memory Access; hardware-accelerated memory copying that runs during VBlank at 100MHz.

; Layer
: Graphics compositing priority. Bitmaps and tilemaps can be assigned to layers 0-2.

== Memory ==

; SRAM
: Static RAM; main system memory. 512KB on gen1 models, 2MB on gen2 models.

; DDR3 DRAM
: 128MB dynamic RAM on F256K2 and Wildbits/K2 (support planned but not yet implemented).

; Flash
: 512KB non-volatile memory storing [[Firmware]] and programs. Each K2 core context has its own 512KB flash area.

; MMU
: Memory Management Unit; maps 8KB blocks of physical memory into the CPU's 64KB address space. See [[Memory_Management]].

; MLUT
: Memory Lookup Table; one of four MMU configurations (MLUT 0-3) for quick switching between memory mapping states.

; Slot
: One of eight 8KB regions in the CPU's 64KB address space:
:* Slot 0: $0000-$1FFF
:* Slot 1: $2000-$3FFF
:* Slot 2: $4000-$5FFF
:* Slot 3: $6000-$7FFF
:* Slot 4: $8000-$9FFF
:* Slot 5: $A000-$BFFF
:* Slot 6: $C000-$DFFF (IO Pages overlay this)
:* Slot 7: $E000-$FFFF

; Block
: 8KB chunk of physical memory that can be mapped into a slot via the MMU.

; IO Page
: Memory-mapped I/O region at $C000-$DFFF. Six pages available (0-5). See [[IO_Pages]].

; Expansion Port
: Slot for 256KB RAM or Flash expansion cartridge. Uses PCI-Express x1 socket form factor.

; Flat Memory
: Direct 24-bit addressing without MMU banking. Available in Core2x with SRAM_EN bit enabled.

; Zero Page / Direct Page
: First 256 bytes of memory used for fast addressing. Moveable anywhere in first 64KB in 65816 native mode.

== Audio ==

; SID
: Sound Interface Device; Commodore 64's famous sound chip. FPGA emulated on gen2 and gen1 F256K; real chip sockets available on F256Jr.

; PSG
: Programmable Sound Generator; AY-3-8910-style chip (FPGA emulated). Directly accessible at $D600. See [[Use_the_PSG]].

; OPL3 (YMF262)
: Yamaha FM synthesis chip. Real chip on F256K; FPGA emulated on other models. Not present on the F256Jr. See [[Use_the_OPL3_YMF262]].

; CODEC
: Audio mixer chip for digital audio output. See [[Use_the_CODEC]].

; SAM2695
: Dream MIDI wavetable synthesis chip (gen2 only). See [[Use_the_Sam2695_Dream_MIDI_chip]].

; VS1053b
: VLSI audio decoder/encoder chip supporting MP3, AAC, Ogg Vorbis, and more (gen2 only). See [[Use_the_VS1053b_chip]].

; MIDI
: Musical Instrument Digital Interface. Gen2 models support synthesizers in SAM2695 and VS1053b, and hardware MIDI in/out ports.

== Input/Output ==

; PS/2
: Keyboard/mouse interface standard. Single port supports both keyboard and mouse. See [[Use_the_PS/2_Mouse]].

; IEC
: Commodore serial bus for connecting disk drives, printers, and other peripherals.

; VIA
: Versatile Interface Adapter (WDC 65C22). VIA0 handles Atari joysticks; VIA1 handles keyboard matrix on F256K series.

; UART
: Universal Asynchronous Receiver-Transmitter; serial communication interface at $D630.

; RTC
: Real-Time Clock; battery-backed timekeeping chip at $D690.

; SD Card
: Storage medium for programs and data. Gen1 has one slot; gen2 has internal and external slots.

; DVI
: Digital Visual Interface; video output on first-gen models (supports both digital and analog signals).

; HDMI
: High-Definition Multimedia Interface; video output using digital TMDS signaling.

; ESP32 Feather
: WiFi module for first-gen models (internal installation).

; Wiznet
: Ethernet/WiFi module for second-gen models with external antenna connector. See [[Wiznet]].

; NES/SNES Controllers
: Supported game controllers via dedicated pin header or Mini-DIN9 connector. See [[Use_the_SNES/NES_controllers]].

== Software & Firmware ==

; MicroKernel
: Primary event-based, near real-time kernel for F256 and Wildbits (developed by Gadget). Supports 65c02 and 65816 in emulation mode. See [[Kernels]].

; OpenFNXKernal
: Community-developed CBM-style kernal alternative with SD Card I/O support. See [[Kernels]].

; SuperBASIC
: BBC BASIC-inspired interpreter; default F256 and Wildbits programming environment. See [[SuperBASIC]].

; DOS
: Minimalistic file management and information shell stored in flash.

; F/Manager (fm)
: Feature-rich file manager, program launcher, and memory exploration software. See [[Firmware]].

; Moreorless (mless)
: Built-in text editor stored in flash. See [[Moreorless]].

; FoenixMgr
: Python scripts for uploading code, flashing firmware, and managing the F256 and Wildbits from a PC or Mac.

; xdev
: Development trampoline firmware component that reacts to FoenixMgr commands (pcopy, runpgz, runpgx).

; CartFlasher (fcart)
: Utility for programming the 256KB Flash Cartridge with 8KB prepared blocks.

; pexec
: Kernel routine for loading and executing PGX/PGZ format programs.

== File Formats ==

; KUP
: Kernel User Program; simple executable format for flash-resident or disk-loaded programs. Header contains signature ($F256), size, slot, and entry point. See [[File_Formats]].

; PGX
: Single-segment executable with 8-byte header. Similar to MS-DOS COM or Commodore PRG format. See [[File_Formats]].

; PGZ
: Multi-segment executable format; can load code/data to multiple memory locations. Supports both 24-bit ('Z') and 32-bit ('z') addressing. See [[File_Formats]].

; Binary
: Raw memory image requiring known load address and boot-to-RAM mode. Development use only.

; .bin
: FPGA core file extension used on F256K2's and Wildbits/K2's FPGA load SD card.

; .uf2
: RP2040 firmware file format for second-gen models.

== Technical Terms ==

; IRQ
: Interrupt Request; hardware signal for event-driven programming. See [[IRQ]] and [[IRQ_Programming]].

; NMI
: Non-Maskable Interrupt; cannot be disabled by software.

; SOF
: Start of Frame interrupt; triggered at beginning of VSYNC.

; SOL
: Start of Line interrupt; triggered at configurable scanline.

; VBlank
: Vertical blanking interval; period between video frames when DMA runs.

; PHI2
: CPU clock signal phase 2; active high when CPU is accessing the bus.

; R/W
: Read/Write signal line (Read = high, Write = low).

; BGR / BGRx
: Color format: Blue, Green, Red byte order. BGRx adds unused padding byte for 4-byte alignment.

; Little Endian
: Byte ordering with least significant byte at lowest address. Used throughout the F256.

; BCD
: Binary-Coded Decimal; number encoding where each nibble represents a decimal digit (0-9). Used in RTC.

== DIP Switch Settings ==

DIP switches configure boot behavior and hardware options. See [[DIP_switches]].

; Boot-from-RAM
: When enabled, kernel searches first 48KB of RAM for programs before checking flash.

; Gamma Enable
: Enables color gamma correction.

; Core Select (K2)
: Two switches select which FPGA context (1-4) to load on F256K2.

== Key Register Addresses ==

; $0000 (MMU_MEM_CTRL)
: MMU Memory Control Register; selects active MLUT and enables editing.

; $0001 (MMU_IO_CTRL)
: MMU I/O Control Register; selects IO page and controls memory mapping flags.

; $D000 (MSTR_CTRL)
: VICKY Master Control Register; enables text, graphics, sprites, tiles, bitmaps.

; $D660 (INT_PENDING)
: Interrupt Pending flags (24-bit).

; $D66C (INT_MASK)
: Interrupt Mask register (24-bit).

; $D6A0 (SYS0)
: System Control Register; controls LEDs, reset, and reads SD card status.

== Development Tools ==

; Calypsi
: C compiler supporting 6502, 65816, and 6809 for F256 development.

; 64tass
: Popular cross-assembler for 6502/65816.

; cc65
: C compiler and toolchain for 6502.

;llvm-mos
: C compiler and toolchain for 6502.

; Quartus Prime Lite
: Intel FPGA programming software. Version 18.1 required for Cyclone IV on gen1 models.

; openFPGALoader
: Open-source FPGA programming tool for Linux and macOS.

== See Also ==

* [[Hardware]]
* [[Memory_Management]]
* [[IO_Pages]]
* [[Firmware]]
* [[SuperBASIC]]
* [[FPGA_Releases]]
* [[Getting_Started]]

[[index.php?title=Category:Reference]]
[[index.php?title=Category:Documentation]]

Template:Main2/Getting Started

2026-01-27T17:06:00Z

1BitFeverDreams: added link to glossary page from Cibee

'''Getting Started'''
* [[Product Specifications]]
* [[Getting Started]]
* [[Glossary]]
* [[Manuals]]
* [[Software for 6502]]
* [[Software for 65816]]
* [[Emulation]]

Use the SNES/NES controllers

2026-01-13T19:50:23Z

1BitFeverDreams: /* Usage */ fixed the NES example code externally linked and added the 2x core delays when triggering in the text examples on this wiki page

== NES and SNES controllers ==
The F256 machines can use these controllers provided they are equipped with an optional [https://c256foenix.com/product/fnx4n4s/?v=5435c69ed3bc FNX4N4S breakout adapter].

The official gamepads of yesteryear work without issue with this and are plentiful in the used market.

Third party modern recreations are sometimes flaky or not working at all. Share you discoveries in the discord!

Super famicom gamepads work very well as substitute for regular SNES gamepads.
[[File:Full complement of gamepads.png|thumb|A fully populated FNX4N4S for the F256K2]]

=== Registers ===
{| class="wikitable"
|+
!Register Name
!R/W
!Address
!NES/SNES
!Description
|-
|PAD_CTRL
|W
|0xD880
|both
|Used to trigger a reading and setting the NES/SNES mode
|-
|PAD_STAT
|R
|0xD880
|both
|Used to verify if the triggered polling of gamepad state is done yet
|-
|PAD0
|R
|0xD884
|both
|Buttons statuses: if cleared, they are pressed. If set, they are unpressed.
|-
|PAD0_S
|R
|0xD885
|SNES
|Same deal; unused by NES. Consult button table below
|-
|PAD1
|R
|0xD886
|both
|Buttons statuses: if cleared, they are pressed. If set, they are unpressed.
|-
|PAD1_S
|R
|0xD887
|SNES
|Same deal; unused by NES. Consult button table below
|-
|PAD2
|R
|0xD888
|both
|Buttons statuses: if cleared, they are pressed. If set, they are unpressed.
|-
|PAD2_S
|R
|0xD889
|SNES
|Same deal; unused by NES. Consult button table below
|-
|PAD3
|R
|0xD88A
|both
|Buttons statuses: if cleared, they are pressed. If set, they are unpressed.
|-
|PAD3_S
|R
|0xD88B
|SNES
|Same deal; unused by NES. Consult button table below
|}

=== Control register ===
{| class="wikitable"
|+
!Register Name
!R/W
!Address
!Bit7
!Bit6
!Bit5
!Bit4
!Bit3
!Bit2
!Bit1
!Bit0
|-
|PAD_CTRL
|W
|0xD880
|NES_TRIG
| -
| -
| -
| -
|MODE
| -
|EN
|-
|PAD_STAT
|R
|0xD880
|NES_TRIG
|DONE
| -
| -
| -
|MODE
| -
|EN
|}

==== Control register bit states: ====
{| class="wikitable"
|+
!Bit Name
!If set to 1
!If cleared to 0
|-
|NES_TRIG
|Launches the polling of the states of all buttons
|Stops polling the states of all buttons
|-
|DONE
|The states of the buttons are ready to be read
|The states of the buttons are not ready
|-
|MODE
|SNES data will be used to populate the PAD registers
|NES data will be used to populate the PAD registers
|-
|EN
|Enables the gamepads
|Disables the gamepads
|}

=== Button table ===
{| class="wikitable"
|+
!MODE
!NES/SNES
!Address
!Pad
!Bit7
!Bit6
!Bit5
!Bit4
!Bit3
!Bit2
!Bit1
!Bit0
|-
|0
|NES
|0xD884
|0
|A
|B
|Select
|Start
|Up
|Down
|Left
|Right
|-
|0
|NES
|0xD886
|1
|A
|B
|Select
|Start
|Up
|Down
|Left
|Right
|-
|0
|NES
|0xD888
|2
|A
|B
|Select
|Start
|Up
|Down
|Left
|Right
|-
|0
|NES
|0xD88A
|3
|A
|B
|Select
|Start
|Up
|Down
|Left
|Right
|-
|1
|SNES
|0xD884
|0
|B
|Y
|Select
|Start
|Up
|Down
|Left
|Right
|-
|1
|SNES
|0xD885
|0
|
|
|
|
|A
|X
|L
|R
|-
|1
|SNES
|0xD886
|1
|B
|Y
|Select
|Start
|Up
|Down
|Left
|Right
|-
|1
|SNES
|0xD887
|1
|
|
|
|
|A
|X
|L
|R
|-
|1
|SNES
|0xD888
|2
|B
|Y
|Select
|Start
|Up
|Down
|Left
|Right
|-
|1
|SNES
|0xD889
|2
|
|
|
|
|A
|X
|L
|R
|-
|1
|SNES
|0xD88A
|3
|B
|Y
|Select
|Start
|Up
|Down
|Left
|Right
|-
|1
|SNES
|0xD88B
|3
|
|
|
|
|A
|X
|L
|R
|}
Note: L refers to the left shoulder button and R refers to the right shoulder button.

=== Usage ===
Example 1: polling a NES controller in PAD0 position and checking if A is pressed:

<pre>
POKE(PAD_CTRL, 0b10000001); //trigger, nes mode, enabled
ASM("NOP"); //a necessary delay with the 2x speed core
ASM("NOP"); //a necessary delay with the 2x speed core
POKE(PAD_CTRL, 0b00000001); //clear trigger
while((PEEK(PAD_STAT) & 0x40) == 0) //loop while this bit is cleared
;
if((PEEK(PAD0) & 0x80) == 0) reactToAPressed();
</pre>

Example 2: polling a SNES controller in PAD2 position and checking if X is pressed:

<pre>
POKE(PAD_CTRL, 0b10000101); //trigger, snes mode, enabled
ASM("NOP"); //a necessary delay with the 2x speed core
ASM("NOP"); //a necessary delay with the 2x speed core
POKE(PAD_CTRL, 0b00000101); //clear trigger
while((PEEK(PAD_STAT) & 0x40) == 0) //loop while this bit is cleared
;
if((PEEK(PAD2_S) & 0x04) == 0) reactToXPressed();
</pre>

Example 3: polling both types of controller in rapid succession (allows the usage of all 8 controllers!)

<pre>
//NES section
POKE(PAD_CTRL, 0b10000001); //trigger, nes mode, enabled
ASM("NOP"); //a necessary delay with the 2x speed core
ASM("NOP"); //a necessary delay with the 2x speed core
POKE(PAD_CTRL, 0b00000001); //clear trigger
while((PEEK(PAD_STAT) & 0x40) == 0) //loop while this bit is cleared
;
//section where reactions are made to the various NES presses

//SNES section
POKE(PAD_CTRL, 0b10000101); //trigger, snes mode, enabled
ASM("NOP"); //a necessary delay with the 2x speed core
ASM("NOP"); //a necessary delay with the 2x speed core
POKE(PAD_CTRL, 0b00000101); //clear trigger
while((PEEK(PAD_STAT) & 0x40) == 0) //loop while this bit is cleared
;
//section where reactions are made to the various SNES presses
</pre>

=== Source code example in C: ===
Check out this simple example displaying the statuses of all 4 NES pads on screen, using hex: https://github.com/Mu0n/F256KsimpleCdoodles/tree/main/NES/src

FPGA Releases

2026-01-13T09:09:03Z

1BitFeverDreams: K2 purple core 1x and flat map core 1x

# move the FG & BG Text LUT to:

=== Important: ===
Most users will want to consume the "Firmware package relases" (taken from here: https://github.com/FoenixRetro/f256-firmware/releases. ) which contain both the latest of the FPGA releases seen here on this page, and the kernel/base programs intended for the flash memory. The page you're ready here is meant for power user who would want to test back compatibility or attempt some roll-backs in case bugs are found, and for readers who want to learn about the release notes of each new FPGA version.

''(* "Purple" refers to the official 2025+ release of the K2; "Black" refers to the first run of K2B boards sent out to the original F256K owners in late 2024)''

=== Latest FPGA core files for all platforms ===
{| class="wikitable"
! colspan="3" |
==== <big>F256Jr2</big> ====
!
! colspan="3" |
==== <big>F256K2</big> ====
|-
!Core
!Link
!Notes
!
!Core
!Link
!Notes
|-
|6502 MMU
|[https://github.com/Mu0n/F256MiscGoodies/blob/main/fpga/Jr2/Classic/2025-01-07/F256Jr2_MMU_Jan8th_2025_OPL3.mcs 08-Jan-2025]
|OPL3 added
!
|6502 MMU
|Black*: [https://github.com/Mu0n/F256MiscGoodies/blob/main/fpga/K2/CNTX1/2025-02-02/CFP95600C.bin 02-Feb-2025]
Purple*: [https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/fpga/K2Purple/CNTX1/CFP95600C.bin 05-Feb-2025]
|fix Onboard Access to a SPI Flash
LCD Splash Screen
|-
|65816 Ext
|[https://github.com/Mu0n/F256MiscGoodies/blob/main/fpga/Jr2/Extended/2024-12-21/F256Jr2_Ext16_Dec21st_2024.mcs 21-Dec-2025]
|Implementation of the 256Bytes
Copy from Flash to RAM before booting.
!
|65816 Ext
|Black*: [https://github.com/Mu0n/F256MiscGoodies/blob/main/fpga/K2/CNTX2/2025-01-07/CFP95616E.bin 07-Jan-2025]
Purple*: [https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/fpga/K2Purple/CNTX2/CFP95616E.bin 06-Jan-2025]
|Updated access to WS6100
UART for the VS1053B
|-
|65816 Ext 2x
|[https://c256foenix.com/product-category/gen2-core/?v=5435c69ed3bc Buy Here]
|2x CPU speed
layer of 16 bit colored text

hardware line drawing

64 more sprites.
!
|65816 Ext 2x
|Black*: [https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/fpga/K2/CNTX4/F256K2x_Cores_Foenix138_BlackBoard_B3B_July27th_2025.bin 27-Jul-2025]
Purple*: [https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/fpga/K2/CNTX4/F256K2x_Cores_Foenix138_B0C_August4th_2025.bin 4-Aug-2025]
|2x CPU speed
layer of 16 bit colored text

hardware line drawing

64 more sprites.
|-
|6809
|[https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/fpga/Jr2/6809/2025-06-15/F256JrJr_FNX6809_June14th_RC0014_0003.mcs 15-Jun-2025]
|WIFI Speed and Interface (added TX_Empty & RX_Empty Flag)
!
|6809
|Black*: [https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/fpga/K2/CNTX3/NitrOS9_Load_BlackBoardB3B_WifiFixed_Sept4th.bin 04-Sep-2025]
Purple*: [https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/fpga/K2Purple/CNTX3/NitrOS9_Load_PurpleBoardB0C_WifiFixed_Sept4th.bin 04-Sep-2025]
|Wifi fix
|-
! colspan="3" |
==== <big>F256Jr</big> ====
!
! colspan="3" |
==== <big>F256K</big> ====
|-
!Core
!Link
!Notes
!
!Core
!Link
!Notes
|-
|6502 MMU
|[https://github.com/Mu0n/F256MiscGoodies/blob/main/fpga/Jr/Classic/F256M_Wbh_Jan26th_2025_RC20_0100.jic 26-Jan-2025]
|fixes Overlay FONT on top of graphic
with Background Color Enabled
!
|6502 MMU
|[https://github.com/Mu0n/F256MiscGoodies/blob/main/fpga/K/F256Kc_WBh_Jan26th_2025_RC16_0001.jic 26-Jan-2025]
|fixes Overlay FONT on top of graphic
with Background Color Enabled
|-
|65816 Ext 2x
|[https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/fpga/Jr/Extended/F256M_Wbh_Jun24th_2025_RC0100_0002.jic 24-Jun-2025]
|Fixed bugs with register 0x0000 and 0x0001
!
|65816 Ext 2x
|[https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/fpga/K/F256Kc_WBh_Jun23th_RC0100_0003_DualSpeed_CPU.jic 23-Jun-2025]
|Fixed bugs with register 0x0000 and 0x0001
|}

=== Previous FPGA core files for all platforms ===
Use these for testing out older softwares and snooping around for persistant issues.
{| class="wikitable"
|+
! colspan="3" |
==== <big>Previous F256Jr2 Cores</big> ====
|-
!Core
!Link
!Notes
|-
|6809
|[https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/fpga/Jr2/6809/2025-06-13/F256Jr2_FNX6809_June13th_RC0017_0002.mcs 13-Jun-2025]
|Move the FG & BG Text LUT to:

$18_3800 $18_383F TEXT_LUT_FG

$18_3840 $18_387F TEXT_LUT_BG
|-
|6809
|[https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/fpga/Jr2/6809/2025-06-11/F256Jr2_FNX6809_June11th_RC0017_0000.mcs 11-Jun-2025]
|big Wishlist
full access to write back the onboard flash
|-
|6809
|[https://github.com/Mu0n/F256MiscGoodies/blob/main/fpga/Jr2/6809/2025-01-17/F256Jr2_FNX6809_Jan17th_RC0014_0002.mcs 17-Jan-2025]
|Fix for the manual Reset
Fix for the readback of Multiplication Values

Endianess

Changes to: Line/Pixel Position
|}

{| class="wikitable"
|+
! colspan="3" |
==== <big>Previous</big> <big>F256K2</big> <big>Cores</big> ====
|-
!Core
!Link
!Notes
|-
|6502 MMU
|Black*: [https://github.com/Mu0n/F256MiscGoodies/blob/main/fpga/K2/CNTX1/2025-01-08/CFP95600C.bin 08-Jan-2025]
Purple*: n/a
|OPL3 implemented
|-
|6502 MMU
|Black*: [https://github.com/Mu0n/F256MiscGoodies/blob/main/fpga/K2/CNTX1/2025-01-07/CFP95600C.bin 07-Jan-2025]
Purple*: n/a
|Instantiation of the UART for the VS1053B @ $DDB0
|-
|6809
|Black*: [https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/fpga/K2/CNTX3/K2_NitrOS9_Load_BlackBoard_Aug26th.bin 26-Aug-2025]
Purple*: [https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/fpga/K2Purple/CNTX3/FNX6809_First_Release_Aug24th_PurpleBoard.bin 24-Aug-2025]
|This is the preliminary version and only works with a PS/2 keyboard plugged in.
If destined for slot 3, rename the file and put in CNTX3/f256k2t9.bin
|}

{| class="wikitable"
|+
! colspan="3" |
==== <big>Previous F256Jr Cores</big> ====
|-
!Core
!Link
!Notes
|-
|6502 MMU
|[https://github.com/Mu0n/F256MiscGoodies/blob/main/fpga/Jr/Classic/F256M_Wbh_Dec23rd_2023_RC18_0100.jic 23-Dec-2023]
|Tiles fix; shifted by one towards the left.
(0100 = Serial RAM/Flash Select)
|-
|6502 MMU
|[https://github.com/Mu0n/F256MiscGoodies/blob/main/fpga/Jr/Classic/F256M_Wbh_Nov18th_2023_RC17_0100.jic 18-Nov-2023]
|In light of decision to dump the big ticket items and the accessories from the store...

* Removed the very SPI core introduced yesterday to drive the FNXNET51 module.
* Removed the DP memory for the MMU and replace it back with simple Registers, which means that when you reset the system, the MMU, Page0 will be reset back to the way it was. However, the caveat is that if you change between RAM to FLASH MMU default value, you need to do a reset, either a debug reset or General Reset because the MMU is now only 32bytes in Size, so, 4 pages of 8 values.
|-
|6502 MMU
|[https://github.com/Mu0n/F256MiscGoodies/blob/main/fpga/Jr/Classic/F256M_WBh_Nov17th_2023_RC16_0111.jic 17-Nov-2023]
|
* No Write Allowed when Debug Port writes in the MMU Memory Zone
* Incorporation of a new SPI Controller to interface with the FNXNET51 module using the NES/SNES MiniDin9 Connector
* ReSync of the Debug Generated RDY to stop the CPU. (untested)
|-
|6502 MMU
|[https://github.com/Mu0n/F256MiscGoodies/tree/main/fpga/Jr/Classic various older]
|
|-
|65816 Ext 2x
|[https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/fpga/Jr/Extended/F256M_Wbh_Jun17th_2025_RC0100_0001.jic 16-Jun-2025]
|CPU runs at 2x speed at 12 MHz
MUST use a 65816 cpu chip,

will not work with the 6502
|-
|6809
|n/a
|n/a
|}

{| class="wikitable"
|+
! colspan="3" |
==== <big>Previous</big> <big>F256K</big> <big>Cores</big> ====
|-
!Core
!Link
!Notes
|-
|6502 MMU
|[https://github.com/Mu0n/F256MiscGoodies/blob/main/fpga/K/2024-12-23/F256K_WBh_Dec23rd_RevB0x_RC14_0000.jic 23-Dec-2023]

|Tiles fix; shifted by one towards the left.
|-
|6502 MMU
|[https://github.com/Mu0n/F256MiscGoodies/blob/main/fpga/K/F256K_WBh_Dec9th_RevB0x_RC13_0000.jic 09-Dec-2023]
|
* Fixes a problem with Interrupt from timer0 that was working on the Jr.
* Resolves a discrepancy between the F256Jr interrupt block and the F256K.
|-
|6502 MMU
|[https://github.com/Mu0n/F256MiscGoodies/blob/main/fpga/K/F256K_WBh_Nov19th_RevB0x_RC12_0011.jic 19-Nov-2023]
|Corrects the issue with no-response from command $20 & $21 (not being processed in the early parser). The Jr doesn't have the issue.
|-
|6502 MMU
|various older
|
|-
|65816 Ext 2x
|[https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/fpga/K/F256Kc_WBh_Jun18th_2025_RC0100_0000_DualSpeed_CPU.jic 18-Jun-2025]
|CPU runs at 2x speed at 12 MHz
MUST use a 65816 cpu chip,

will not work with the 6502
|-
|6809
|N/A yet
|N/A yet
|}

---old version will be kept at the bottom for a while in case errors are found above---

== FPGA Upgrade Guide ==

==== How to Upgrade the F256K FPGA (and F256Jr) ====
Note that the below Video Guide applies to both the F256K & F256Jr, despite it just being titled F256K.

<youtube>U7bq7t_qjxg</youtube>

You will need to download Quartus Prime Lite 18.1 Edition, since you are going to target a EP4CE15 FPGA (Cyclone 4).

Do not update to the latest version of Quartus Prime Lite, as the latest version doesn’t support that family of FPGA anymore and the software is very big.

Also, one might want to download only the "Intel® Quartus® Prime Programmer and Tools" as opposed to download the whole software by clicking on "Additional Software"

[https://www.intel.com/content/www/us/en/software-kit/665990/intel-quartus-prime-lite-edition-design-software-version-18-1-for-windows.html Intel Quartus Prime Lite Edition 18.1 for Windows]

[https://www.intel.com/content/www/us/en/software-kit/665988/intel-quartus-prime-lite-edition-design-software-version-18-1-for-linux.html Intel Quartus Prime Lite Edition 18.1 for Linux]

==== How to Upgrade the FPGA for the F256K2 ====
It is possible that there will be more graceful methods in the future, but for now, the easiest is to pop off the uSD card found on the left side of the board marked "uSD Card / FPGA Load" and to replace the .bin files inside the directory of the root of that uSD card, using a modern computer.

This will of course imply that you open up your case. [[Optional Upgrades#Opening the F256K case|There is a guide]] on how to do so for the original F256K enclosure. Perhaps the F256K2 enclosure will be similar.

For those unfamiliar with the process of removing the uSD card from these slide-operation holders here is the process:

1) very gently press down on the middle metal locking slider that goes across on top of the uSD card and slide it towards the left.

2) the uSD card and its locking slider will now open up by rotating towards the left with a hinge on the left side

Inside the root of this uSD card, there are four folders marked as CNTX# where # is a number from 1 to 4. Simply replace the .bin file therein to update any one given core. You may completely ignore .prm files since they do not affect the F256K2.
{| class="wikitable"
|+
!Folder
!Hard coded file name
!Typical* usage
!CPU in the FPGA
|-
|CNTX1
|CFP95600C.bin
|F256 Classic mode with a memory management unit (MMU), where the CPU sees 64k at once
|65816 acting as 6502
|-
|CNTX2
|CFP95616E.bin
|F256 Extended mode with a flat memory map all accessible at once
|65816
|-
|CNTX3
|f256k2t9.bin
|F256 with the 6809 core (planned) or 68000 core (planned)
|6809
|-
|CNTX4
|foenix138.bin
|F256 with 2x CPU speed Extended mode with a flat memory map all accessible at once
|65816
|}

====== Note* on typical usage ======
As long as you keep the proper hard coded names tied to their folder names, you can slide any core to any slot. For example, if you want the 2x core to be in the CTNX2 folder, just rename it appropriately to CFP95616E.bin as you put it into CTNX2/.

====== F256K2 core prep steps: ======

# Take care of placing the bin file in the FPGA load uSD card
# Set the core selecting DIP switches at the back of the unit. Down (towards bottom of the unit) = 0, Up (towards the upper side of the unit) = 1. See below for all possibilities.
# Power up the unit. If this is the first time you're using that core and you've never done step 4 for it, it's normal to not have a properly booted initial software (ie superbasic or otherwise)
# Write the firmware to the content of the flash. Each of the 4 cores have their own 512kb of reserved flash space that are selected at the same time as the core itself from the uSD FPGA load card. Once they are written to, they are set for future usages as you switch between cores and won't require further flash writes, unless you're doing updates.

====== Core selecting DIP switches in the back ======
{| class="wikitable"
|+
!Core 1
!Core 2
!Core 3
!Core 4
|-
|
[[File:Core1.png|thumb]]
|
[[File:Core3.png|thumb]]
|
[[File:Core2.png|thumb]]
|
[[File:Core4.png|thumb]]
|-
|0 0
|1 0
|0 1
|1 1
|}

==== How to Upgrade the FPGA for the F256Jr. the 2nd ====
Go look at this [[FPGA Upgrade Guide (F256JrJr)|guide here in the wiki]].

=== Suggested USB Blaster (K and Jr. only) ===

Earth People Technology
[https://www.amazon.ca/JTAG-Blaster-Intel-Altera-Programmer/dp/B07BZMSZ3G/ref=sr_1_3?crid=WWV8P0OHVCE3&keywords=altera+usb+blaster&qid=1688067039&sprefix=altera+usb+blaster%2Caps%2C113&sr=8-3]
[https://earthpeopletechnology.com/?wpsc-product=ept-2232h-sp-s1]

Terasic USB Blaster (low cost version)
[https://www.digikey.ca/en/products/detail/terasic-inc/P0302/2003484]
[https://www.terasic.com.tw/cgi-bin/page/archive.pl?Language=English&CategoryNo=&No=46#contents]

Chinese Knockoff (please avoid if possible)

=== Open Source blaster software (K and Jr. only) ===

For those who are struggling to program the FPGA with Linux or Apple, Stef found this great tool:

https://github.com/trabucayre/openFPGALoader/releases

Software for 6502

2026-01-12T18:33:39Z

1BitFeverDreams: /* Sample Code */ MikeC github

Note that when an hex address is given, it's meant to instruct as to which address to bload or to send (ie foenixmgr python script) the program (ie a .bin file) to before running it. For extra help on how to run .bin files and almost every possible scheme that has to be used to run program, you can consult this video that's also part of [[Getting Started]], this one: https://www.youtube.com/watch?v=0ShFv89KGDs

Many download links are posts in the main [https://discord.gg/9vjUEGgcUS Foenix Retro Systems discord server] which will require you to join in order to get to them.

A [[Getting Started#Demos Archive|Demo Archive]] was put together in September 2023 to get ready to show to youtubers, some of these are linked once more, in this page.

There's also the Foenix Marketplace website maintained by EMWhite with its own collection of articles and software http://apps.emwhite.org/foenixmarketplace/.

===== Curated SD card collection of games, demos, utilities =====
Here is a download link to a zip file meant to be extracted into the root of an SD card: https://github.com/Mu0n/F256MiscGoodies/tree/main/SDCard_Collection

Best to wipe out your SD card and start anew with the contents of this extracted to root. Micah's file manager doesn't like long lists of files so it really is best to not overdo it. I tried to minimize the files in root, but I couldn't for everything.

Open the readme.txt file with moreorless to see some instructions about the collection. Best to run /- fm first, then open the readme.txt from it

== Applications ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|F256 f/term
|Terminal emulator for F256K and Jr with classic (flat) memory load
|Micah
| - fterm.pgZ or use f/manager
|https://github.com/WartyMN/F256-terminal/blob/main/release/fterm.pgZ
|-
|FoenixTarot
|Tarot card readings in SuperBasic
|Mike
|basic
|https://github.com/mcassera/FoenixTarot/tree/main
|-
|Forthf256
|Forth implementation
|Vasyl
|pgz in its forth/ folder
|https://github.com/VasylTsv/ForthX16
|-
|WildBits Graphic Toolkit
|(fmr. F256-GraphicToolkit) Sprite editor, Tilemap editor, Font editor + misc tools
|econtrerasd
|basic
|https://github.com/econtrerasd/F256-GraphicToolkit/releases
|}

== Demos ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|badapple
|A 80x60 textmode port of Bad Apple, uses the VS1053b for quality mp3 audio. Needs a Jr2 or K2!
|Mu0n
|pgz*
|*unzip badapple.zip into the root of your SD card. If done right, the 3 files within will be in the demos/ folder. The program expects its data file there when it runs. https://github.com/Mu0n/F256MiscGoodies/blob/main/apps/badapple.zip
|-
|balls
|Draw a good quantity of multiplexed sprites, fast. Balls bouncing around
|celton
|pgz
|https://github.com/FoenixRetro/demos/blob/main/MultiplexedSprites.md
|-
|F256Archon
|Splash screen intro, plays MIDI using the SAM2695, requires a K2 or Jr2
|Mu0n
|pgz
|https://github.com/Mu0n/F256Archon/releases
|-
|f256_life
|An implementation of Conway's game of life
|mgr42
|pgz
|https://github.com/rmsk2/f256_life
|-
|F256 Mandelbrot
|Draws Mandelbrot set fast (5 mins) using coprocessor math. Allows to zoom into the set.
|mgr42
|uses basic loader
|https://github.com/rmsk2/F256_Mandelbrot
|-
|F256ShowCase
|Shows sliding tiling graphics, moves with joystick
|eriktier
|$0000
|https://github.com/pig-games/F256Showcase
|-
|fnxmas23
|PSG mod music, scrolling text, sound effects, must see demo!
|dwsJason and digarok
|pgz
|https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/apps/xmas24_k2.pgz revised version that can run on wave 2 Jr2 and K2 as well
|-
|foenixmas23
|Xmas 2023 demo with SID music from the classic 1983 C64 xmas demo
|EMWhite
|uses basic loader
|http://apps.emwhite.org/shared-files/815/?foenixmas23.zip
|-
|livingworlds
|Living Worlds, a port of a color cycling by Mark Ferrari, ported here on the F256 by haydenkale
|haydenkale
|$0000
|https://github.com/clandrew/livingworlds/tree/e4532e0d530b76ccb90368fdf5ad10bfa2deeb12
|-
|mandel
|Will draw a mandelbrot set in 3 hours, more useful as a stability test than a useful fractal program
|Mu0n
|basic
|https://github.com/Mu0n/F256KbasicBASICdoodles?tab=readme-ov-file#fractal
|-
|mariobros
|Tilemap and platformer test based on Mario Bros. (1983)
|beethead
|pgz
|https://github.com/noyen1973/mariobros
|-
|pendulum
|Sprite and MIDI demo
|MikeC
|pgz
|https://github.com/mcassera/pendulum
|-
|wormhole
|Shows a fast wireframe animation of a wormhole
|haydenkale
|pgz or bin at $0000
|https://github.com/clandrew/wormhole?tab=readme-ov-file
|}

== Games ==

{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|bbombers
|Boulder Bombers (Alpha-2) Clone of Canyon Bombers
|Scott (xDraconian)
|pgx
atari joystick
|https://github.com/scttgs0/BoulderBombers<nowiki/>https://github.com/scttgs0/BoulderBombers/releases/tag/alpha_2
|-
|Bombsweeper
|Bomb sweeper port
|beethead
|pgz
|https://discord.com/channels/691915291721990194/855689509520932885/1196352934083035156
|-
|Cosmic
|Shoot 'em up
|beethead
|pgz
|https://discordapp.com/channels/691915291721990194/1054250238308790342/1175982979537969214
|-
|F256-Trek
|Updated Trek, with modern F256 Graphics
|econtrerasd
|basic
|[https://github.com/econtrerasd/Trek-F256/releases/tag/v1.0 https://github.com/econtrerasd/Trek-F256/releases]
|-
|F256 two to the power of eleven
|Port of the puzzle game of 2048
|mgr42
|pgz
|https://github.com/rmsk2/F256_2048<nowiki/>
|-
|fillerup
|Fill 'er Up (WIP)
Qix-like game
|Scott (xDraconian)
|pgx
atari joystick
|https://github.com/scttgs0/Fill-er-up
|-
|FusionDrive
|An outrun type game that also plays a MIDI soundtrack
|Mu0n
|pgz
|wip v0.2, can use a NES pad #1 to move around, or left/right arrow keys currently https://github.com/Mu0n/F256KsimpleCdoodles/tree/main/NoFussDemos
|-
|jewelkeeper
|Sokoban port
|beethead
|pgz
|https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/apps/jewelkeeper.pgz<nowiki/>You can now specify a level file when loading the game <code>/- jewelkeeper.pgz <levels.txt></code>. Find more levels at https://www.sourcecode.se/sokoban/levels.php. Keep in mind the maximum level dimension is 20x15, anything larger will be ignored
|-
|Jr Wördl
|port of Wordle
|AgeAgeEye
|basic
|https://github.com/ageageeye/Superbasic-F256Jr-examples
|-
|kartdemo
|Kart racing game
|SprySloth
|pgz
|https://discord.com/channels/691915291721990194/1225217654487253094/1228246780840513556
|-
|Lair of the Lich King
|Rogue like dungeon crawler. Demo has 3 levels; full has 25+
|Micah
| - lkdemo/lk.pgz
|[https://discord.com/channels/691915291721990194/1230670413361844244/1317256215566487593 1.0 Beta 19 Demo]
|-
|livewire
|Livewire (WIP)
Tempest-like game
|Scott (xDraconian)
|pgx
atari joystick
|https://github.com/scttgs0/Livewire
|-
|Maze-Munch
|Pac-Man clone
|SprySloth
|pgz
|https://github.com/cmassat/Maze-Munch
|-
|pdefense
|Planetary Defense (WIP)
|Scott (xDraconian)
|pgx
mouse
atari joystick
|https://github.com/scttgs0/PlanetaryDefense
|-
|Shanghai/Mahjongg
|A clone of Shanghai. Also known as Mahjongg
|mgr42
|pgz or KUP
mouse needed
|https://github.com/rmsk2/f256_mahjong
|-
|Ski-Jr
|Ski game downhill
|digarok
|basic
|https://github.com/digarok/superbasic-traveler/blob/main/ski-jr.bas
|-
|Track & Field
|Olympic Game by Konami (WIP)
|Scott (xDraconian)
|pgz
atari joystick or keyboard
|
|-
|Tetris
|Good old 80's game
|Daniel Tremblay (Grenouye)
|pgz
atari joystick or keyboard
|https://github.com/dtremblay/c256-tetris/tree/f256k
|}

== Game Jam #01 - April 6th/7th 2024 ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|15puzzle
|Number sort puzzle
|mgr42
|pgz
|https://github.com/rmsk2/f256_15puzzle/releases<nowiki/>
|-
|Flight Simulator
|flying simulator
|sduensin
|pgz
|https://cdn.discordapp.com/attachments/1225481966200029286/1227764847819620454/shotel.pgz
|-
|frisbee
|Frisbee throw past sport game
|dwsJason
|pgz
|https://github.com/dwsJason/f256/blob/develop/merlin32/frisbee/frisbee.pgz
|-
|Impasse
|Shoot 'em up
|digarok
|pgz
|https://discord.com/channels/691915291721990194/1225481966200029286/1227075699895046235
|-
|soccur
|mutliplayer game of soccer
|beethead
|pgz
|executable:https://discord.com/channels/691915291721990194/1225481966200029286/1226808228948611184
source code:
https://discord.com/channels/691915291721990194/1225481966200029286/1226812472069980232
|-
|Trek
|port of classic Star Trek game
|contrerasd
|basic
|https://discord.com/channels/691915291721990194/1225481966200029286/1226727849944289341
|-
|Typing Star
|typing reaction game
|haydenkale
|pgz
|https://github.com/clandrew/typestar
|-
|}

== Game Jam #02 - October 25th-November 1st 2024 ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|Bach's MIDI Hero
|Free MIDI/PSG play + note play tutorial
|Mu0n
|pgz
the MIDI feature requires a F256K2 or F256Jr2; a legacy PSG option also allows F256K and F256Jr to still hear it. Optionally uses a MIDI in controller plugged in.
|https://github.com/Mu0n/F256KsimpleCdoodles/releases/download/v1.2/BachHero.pgz
|-
|f256_snake
|
|mgr42
|pgz. Use cursor keys, Atari joystick or SNES pad to play
|https://github.com/rmsk2/f256_snake
|-
|fnxsnake
|
|silk-neon
|pgz
|https://github.com/ksiondag/fnxsnake
|-
|The Hallow
|
|beethead
|pgz
|https://github.com/noyen1973/FoenixGameJamOct2024
|-
|Halloween Birthday
|
|SprySloth
|pgz
|https://github.com/cmassat/GameJam2024_F256K
|-
|Haunted Mansion
|
|digarok
|superbasic
|https://github.com/digarok/fnxgamejam-haunted-mansion
|-
|Kooyan
|
|Grenouye
|pgz
|https://github.com/dtremblay/kooyan.git
|-
|Spooky Run
|
|dwsJason
|pgz
|https://github.com/dwsJason/spooky
|-
|Trick or Treat
|
|Mike
|pgz
|https://github.com/mcassera/TrickOrTreat
|-
|Ultima III - Exodus
|port
|Minstrel Dragon
|pgz
|https://github.com/minstreldragon/F256_Ultima_3
|-
|Warlock
|remake of 68000 game
|xDraconian
|pgz
atari joystick
DOWN=change_level
UP=jump
UP-LEFT=leap
UP-RIGHT=leap
|https://github.com/scttgs0/Foenix_GameJam_Oct2024
|}

== Game Jam #03 - April 18th-April 27th 2025 ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|Arcade Shanghai v1.2
|Shanghai clone
|contrerasd
|basic, keep the .bas program in root, the rest in the provided ashanghai/ folder
|https://github.com/econtrerasd/ashanghai/releases
|-
|Bawk Bawk Cluck Cluck
|Chicken themed platformer
|beethead
|pgz
|https://github.com/noyen1973/FoenixGameJamApr2025
|-
|BitLadder
|Shoot 'Em Up
|Mu0n
|pgz. For full sound compatibility, a Jr2 or K2 is needed.
Uses 4 sound chips! (PSG, SID, OPL3, MIDI)
|https://mu0n.itch.io/bitladder
|-
|F256_Commando
|Commando port
|SprySloth
|pgz
|https://github.com/cmassat/F256_Commando
|-
|F256_LodeRunner
|Lode Runner port
|Minstrel Dragon
|pgz
|https://github.com/minstreldragon/F256_Loderunner/releases
|-
|Mahjong
|Shangai clone
|mgr42
|pgz
|https://github.com/rmsk2/f256_mahjong/releases
|-
|Quarth
|Block placement arcade game
|Grenouye
|pgz
|https://grenouye.itch.io/f256-quarth
|-
|Skee(ster)-Ball
|
|Mike
|pgz
|https://github.com/mcassera/skeeball256/tree/main
|}

== Game Jam #04 - November-December 2025 ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|Fallitaire
|A cozy fall-themed twist on Pyramid Solitaire, built for the Foenix F256K2 Game Jam!
|Programmer Vs World
|bas
|https://programmervsworld.itch.io/fallitaire
|-
|H.E.R.O.
|Port of the classic game H.E.R.O.
|Cibee
|pgz
|https://c1bee.itch.io/hero
|-
|Leaderboard
|Golf game
|xDraconian
|pgz
|https://discord.com/channels/691915291721990194/1424187774642290799/1456104940186501132
|-
|Pitfall
|Port of the classic Pitfall game from Activision
|MinstrelDragon
|pgz
|https://minstrel.itch.io/pitfall-foenix-f256x
|-
|Return of the Falcon
|
|Callisto
|TBD
|
|-
|Swicheroo
|An Alternate Puzzle Game
|jbaker8935
|pgz
|https://jbaker8935.itch.io/switcheroo
|-
|Track Day
|v1.0 top down race game vs computer controlled opponents
|MikeC
|pgz
|https://mcassera.itch.io/track-day-racing
|}

== Music ==

{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|cozyMIDI
|Plays a SMF with the SAM2695 or VS1053b
|Mu0n
|pgz
|cozyMIDI v2.5 can open and play type 0 and type 1 standard MIDI files (SMF)
needs a Jr2 or K2
with a 2x core at https://github.com/Mu0n/F256KsimpleCdoodles/tree/main/NoFussDemos

run operation 1: just as itself, it will force you to pick a midi file in the 'midi/' folder /- cozymidi

run operation 2: in f/manager, if you put this as <code>midiplayer.pgz</code>in the '_apps/' folder, f/manager will open midi file with it when you launch .mid files.

Program link: https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/cozymidi.pgz
|-
|digestMidi
|converts .mid to .dim
|Mu0n
|pgz
|.mid files are slow to load, parse and prepare for a playback. This tool comes in to convert them into a .dim format that strips out unnecessary MIDI commands and sets it up for timer0 time delays. Works with type 0 and type 1 standard midi files. This tools does the conversion and lets you hear the result.
Find the latest version here: https://github.com/Mu0n/F256MiscGoodies/tree/main/apps
|-
|EdInHisLib
|SID+OPL3 simultaneously
|beethead, ported from xantax
|pgz
|F256 port: https://discordapp.com/channels/691915291721990194/1054249926521016392/1184413356598231120
original: <nowiki>https://csdb.dk/release/?id=170898</nowiki>. Not 100% accurate but close.
|-
|F256amp
|mp3, ogg, wav, wma file playback
|Mu0n
|pgz
|(aka audioplayer.pgz) v2.3 Needs a Jr.2 or K2 since it uses the VS1053b chip.
For a starter collection of .mp3 and other audio files, check the SD curated collection here: https://github.com/Mu0n/F256MiscGoodies/tree/main/SDCard_Collection
run operation 1: just as itself, it will force you to pick an audio file. it expects a <code>media/mp3/</code> folder, but it can live without it and peek into the root instead.

run operation 2: with an argument, it will auto-play it: /- f256amp yourmp3file.mp3

run operation 3: in f/manager, if you put this as <code>audioplayer.pgz</code> in the '_apps/' folder. This lets f/manager automatically open up .mp3, .wav, .ogg, .wma that you press enter on.

Program link: https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/f256amp.pgz
|-
|FireJam
|all chips, music playing with MIDI in
|Mu0n
|pgz
|v1.2 MIDI in and out capable, it will still partially work with a Jr. (PSG, and SID if you have them), a K (PSG, SID, OPL3) and the newest wave 2 Jr2 and K2 (PSG, SID, OPL3, SAM, VS1053b).
Best to use with a MIDI in controller, but it'll be controllable with arrows and space to make notes individually, or the F keys to start beats. https://github.com/Mu0n/F256KsimpleCdoodles/tree/main/NoFussDemos
|-
|jrtracker
|Tracker based in basic and uses the PSG
(considered obsolete, use tracker2)
|contrerasd
|basic
|https://ptb.discord.com/channels/691915291721990194/1008139105386889346/1188292876984143983
|-
|modo
|MOD player using the PSG
|dwsJason and digarok
|pgz
|https://discordapp.com/channels/691915291721990194/855689509520932885/1190723114661859429
|-
|Musik
|Music piece demo using MIDI
|Mike
|pgz
|https://github.com/mcassera/Musik/blob/main/Musik.PGZ<nowiki/>Musikalisches Würfelspiel
Requires a Jr2 or K2 since it uses MIDI
|-
|opl3snooper
|playback of VGM files (that use opl2 and opl3) and MIDI in
|Mu0n
|pgz
|v1.1 mainly plays back vgm files, but you can pause it and snoop around the channel instruments and play up to 18 note polyphony with MIDI in. expects a collection in media/vgm/, or it will browse from the root if it can't find.
It can load a .spl (Simple PLaylist) text file, which is one file per line, including their respective paths.
Requires a Jr2 or K2 with a 2x core to use the extra bank of SRAM.
For a starter collection of .vgm files, check the SD curated collection here: https://github.com/Mu0n/F256MiscGoodies/tree/main/SDCard_Collection
run operation 1: just as itself, it will force you to pick a midi file in the 'media/vgm/' folder

run operation 2: in f/manager (v1.1b9 and up), if you put this as <code>vgmplayer.pgz</code>in the '_apps/' folder, f/manager will open midi file with it when you launch .vgm files.

Program link: https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/opl3snooper.pgz
|-
|opl3tweak
|uses MIDI in, plays 18 channels polyphony in real time to the YMF262 OPL3. Fish for random register values.
|Mu0n
|pgz
|v0.1. Can't save or load instrument definitions yet. Needs a K2 with a MIDI in currently. https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/opl3tweak.pgz
Arrows to move around, + and - keys to incr/decr values or type in a hex value directly under the highlighted position.
|-
|piano
|Plays some PSG notes with the keyboard
|Mu0n
|basic
|https://github.com/Mu0n/F256KbasicBASICdoodles?tab=readme-ov-file#pulse-sound-generator-piano
|-
|playvgm
|plays a headless vgm file with OPL3
|G33kyAndIKnowIt
|pgx
|https://github.com/natebarney/playvgm-f256k
some example music files can be gotten from this post:
[https://discord.com/channels/691915291721990194/975117322836656138/1220366429640065074 https://discord.com/channels/6][https://discord.com/channels/691915291721990194/975117322836656138/1220366429640065074 91915291721990194/975117322836656138/1220366429640065074]

1) open a normal .vgm into a hex editor <nowiki/>and cut out the header bytes from 0x00 to 0x<nowiki/>FF

2) run by first using superbasic's '''''bload''''' '''''"yourmusicfile", $01000'''''
followed by running this program with '''''/- playvgm.pgx'''''
|-
|sidtweak
|uses MIDI in, plays 6 channels polyphony in real time to the dual SID. Fish for random register values.
|Mu0n
|pgz
|v0.1. Can't save or load instrument definitions yet. Needs a K2 with a MIDI in currently. https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/sidtweak.pgz
Arrows to move around, + and - keys to incr/decr values or type in a hex value directly under the highlighted position.
|-
|rawsidplayer
|plays raw PSID files from the HVSC collection, converted by zigreSID
|Mu0n
|pgz
|(formely psidplayer) v0.2 find rawsidplayer.pgz and a starter .rsd file (raw sid dumps). For a starter collection of .rsd files, check the SD curated collection here: https://github.com/Mu0n/F256MiscGoodies/tree/main/SDCard_Collection
extract sid.zip into a folder /sid/ in the root of your SD card, that's where psidplayer.pgz will first look to let you pick a file. failing that, it will fall back to the root folder and let you navigate.

program link:

https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/rawsidplayer.pgz
|-
|tracker2 v1.5
|Like jrtracker.bas, but using both PSGs
|contrerasd
|basic
|https://github.com/econtrerasd/Tracker2/releases
|}

== Uti<nowiki/>lities ==

{| class="wikitable"
|+
!Program
!Descrip<nowiki/>tion
!Author
!Notes on running
!Link
|-
|basic2text
|A simple utility for translating Commodore BASIC (all variants) from its native tokenized file format to a text format that can be opened with SuperBASIC. Does not perform any code translation: all adaptation is up to you.
|Micah
|pgZ
|https://github.com/WartyMN/F256-BasText/releases/latest
|
|-
|dcopy
|A tool to copy files from one drive to another or to/from your PC via RS-232 and a nullmodem cable
|mgr42
|pgz/flash
|https://github.com/rmsk2/f256_dcopy
|
|-
|f/manager
|A general file utility, launcher, and memory viewing program. Dual-panel file/memory browsers; copy between disks, between folders on same disk, and from memory to disk and vice versa; delete, rename, and duplicate files; view files as hex or text (with word-wrap); launch applications and known file types; set the RTC clock; search in RAM and flash. Works with internal SD card and IEC devices such as FNX1591 and Commodore 1541. Can be installed in primary flash position ahead of SuperBASIC or DOS, or at a higher location. Can also be run from disk with "- fm.pgz".
|Micah
|pgZ/flash
|https://github.com/WartyMN/F256-FileManager/releases
|
|-
|f256_reset
|A small utility that lets you reset the machine through this piece of flash software
|mgr42
|flash
|https://github.com/rmsk2/f256_reset
|
|-
|fcart
|A program that allows to write data to flash expansion cartridges
|mgr42
|pgz, on-board and cartridge flash
|https://github.com/rmsk2/cartflash
|
|-
|flashcart
|Allows to wipe a block of flash or write a program to a flash cart, from this basic program from the F256Jr/K
|redfool.
|basic
|https://github.com/Red-Fool/F256_FlashCart/tree/main
|
|-
|flashselect
|Allows to select a program to start from a flash cartridge via a menu
|mgr42
|pgz, on-board and cartridge flash
|https://github.com/rmsk2/flashselect
|
|-
|fonts
|A variety of fonts using the standard F256 character set arrangement. Load with the F256 file manager (f/manager), or your own code.
|Micah
|(not a program)
|[https://github.com/WartyMN/Foenix-Fonts/tree/main https://github.com/WartyMN/Foenix-Fonts]
|
|-
|midiStuff
|Test program for a F256K2 or F256Jr2 that sends MIDI data to the internal sam2695 dream chip that produces MIDI based audio. Also test a keyboard controller plugged in the MIDI in port.
|Mu0n
|pgz
|https://github.com/Mu0n/F256KsimpleCdoodles/blob/main/README.md#midistuff
|
|-
|moreorless
|A text editor for the Foenix 256 line of computers
|mgr42
|pgz
|https://github.com/rmsk2/moreorless/releases/
|
|-
|pgz2flash
|A program for your Linux, Windows or MacOS machine to turn any PGZ or SuperBASIC program into a KUP which can be run from cartridge or onboard flash memory
|mgr42
|Executable for modern computers
|https://github.com/rmsk2/pgz2flash
|
|-
|sidTester
|Simple superbasic program that tests out all 3 voices of the SID1 on the Jr (if populated), K, Jr2 and K2. Ported by Mu0n, made by andy on HackJunk.com https://hackjunk.com/2017/11/07/commodore-64-sid-tester/
|andy
|basic
|https://github.com/Mu0n/F256MiscGoodies/blob/main/apps/sidtester.bas
|
|-
|testsuite.bas
|a series of tests for your F256, video modes and sound chips
|econtrerasd
|basic
|run from the root,
https://github.com/econtrerasd/testSuite-F256/releases
|
|-
|wget<nowiki/>
|<nowiki/>fetches a file from a http address if you have a network connection active. Works with the K and Jr. ESP32 Feather 'huzzah' board. Not meant to be used with the K2 and Jr2 Wiznet chip.
|gadget
|<nowiki/>pgz/flash
|https://github.com/ghackwrench/F256_wget
|
|}

== Sample Code ==

{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|Assembly examples
|Sample programs for several features of the Foenix F256K and Jr.
|mgr42
|read github
|https://github.com/rmsk2/Hello_Foenix256_Jr/blob/main/testprogs.md
|-
|cc65 example
|c example code
|gadget
|read github
|https://github.com/ghackwrench/F256_Jr_Kernel_DOS
|-
|digarok basic stuff
|Lots of basic examples
|digarok
|read github
|https://github.com/digarok/superbasic-traveler/tree/main
|-
|MikeC repos
|Various projects in assembly
|MikeC
|read github
|https://github.com/mcassera
|-
|Mu0n's F256K asm doodles
|Some asm examples
|Mu0n
|read github
|https://github.com/Mu0n/F256KsimpleASMdoodles
|-
|Mu0n's F256K basic doodles
|Some basic examples
|Mu0n
|read github
|https://github.com/Mu0n/F256KbasicBASICdoodles
|-
|Mu0n's F256K C doodles
|Some C examples
|Mu0n
|read github
|https://github.com/Mu0n/F256KsimpleCdoodles
|-
|Raúl SQ basic repo
|F256 SuperBASIC Trigonometry
|Raúl SQ
|basic
|https://github.com/raul-sq/FoenixF256K2
|-
|tcp example
|connects to a server and gets typed in text echoed back to you
|gadget
|$2000
|https://github.com/ghackwrench/F256_example_tcp
|}

Software for 6502

2026-01-12T18:32:48Z

1BitFeverDreams: /* Demos */ pendulum demo from MikeC

Note that when an hex address is given, it's meant to instruct as to which address to bload or to send (ie foenixmgr python script) the program (ie a .bin file) to before running it. For extra help on how to run .bin files and almost every possible scheme that has to be used to run program, you can consult this video that's also part of [[Getting Started]], this one: https://www.youtube.com/watch?v=0ShFv89KGDs

Many download links are posts in the main [https://discord.gg/9vjUEGgcUS Foenix Retro Systems discord server] which will require you to join in order to get to them.

A [[Getting Started#Demos Archive|Demo Archive]] was put together in September 2023 to get ready to show to youtubers, some of these are linked once more, in this page.

There's also the Foenix Marketplace website maintained by EMWhite with its own collection of articles and software http://apps.emwhite.org/foenixmarketplace/.

===== Curated SD card collection of games, demos, utilities =====
Here is a download link to a zip file meant to be extracted into the root of an SD card: https://github.com/Mu0n/F256MiscGoodies/tree/main/SDCard_Collection

Best to wipe out your SD card and start anew with the contents of this extracted to root. Micah's file manager doesn't like long lists of files so it really is best to not overdo it. I tried to minimize the files in root, but I couldn't for everything.

Open the readme.txt file with moreorless to see some instructions about the collection. Best to run /- fm first, then open the readme.txt from it

== Applications ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|F256 f/term
|Terminal emulator for F256K and Jr with classic (flat) memory load
|Micah
| - fterm.pgZ or use f/manager
|https://github.com/WartyMN/F256-terminal/blob/main/release/fterm.pgZ
|-
|FoenixTarot
|Tarot card readings in SuperBasic
|Mike
|basic
|https://github.com/mcassera/FoenixTarot/tree/main
|-
|Forthf256
|Forth implementation
|Vasyl
|pgz in its forth/ folder
|https://github.com/VasylTsv/ForthX16
|-
|WildBits Graphic Toolkit
|(fmr. F256-GraphicToolkit) Sprite editor, Tilemap editor, Font editor + misc tools
|econtrerasd
|basic
|https://github.com/econtrerasd/F256-GraphicToolkit/releases
|}

== Demos ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|badapple
|A 80x60 textmode port of Bad Apple, uses the VS1053b for quality mp3 audio. Needs a Jr2 or K2!
|Mu0n
|pgz*
|*unzip badapple.zip into the root of your SD card. If done right, the 3 files within will be in the demos/ folder. The program expects its data file there when it runs. https://github.com/Mu0n/F256MiscGoodies/blob/main/apps/badapple.zip
|-
|balls
|Draw a good quantity of multiplexed sprites, fast. Balls bouncing around
|celton
|pgz
|https://github.com/FoenixRetro/demos/blob/main/MultiplexedSprites.md
|-
|F256Archon
|Splash screen intro, plays MIDI using the SAM2695, requires a K2 or Jr2
|Mu0n
|pgz
|https://github.com/Mu0n/F256Archon/releases
|-
|f256_life
|An implementation of Conway's game of life
|mgr42
|pgz
|https://github.com/rmsk2/f256_life
|-
|F256 Mandelbrot
|Draws Mandelbrot set fast (5 mins) using coprocessor math. Allows to zoom into the set.
|mgr42
|uses basic loader
|https://github.com/rmsk2/F256_Mandelbrot
|-
|F256ShowCase
|Shows sliding tiling graphics, moves with joystick
|eriktier
|$0000
|https://github.com/pig-games/F256Showcase
|-
|fnxmas23
|PSG mod music, scrolling text, sound effects, must see demo!
|dwsJason and digarok
|pgz
|https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/apps/xmas24_k2.pgz revised version that can run on wave 2 Jr2 and K2 as well
|-
|foenixmas23
|Xmas 2023 demo with SID music from the classic 1983 C64 xmas demo
|EMWhite
|uses basic loader
|http://apps.emwhite.org/shared-files/815/?foenixmas23.zip
|-
|livingworlds
|Living Worlds, a port of a color cycling by Mark Ferrari, ported here on the F256 by haydenkale
|haydenkale
|$0000
|https://github.com/clandrew/livingworlds/tree/e4532e0d530b76ccb90368fdf5ad10bfa2deeb12
|-
|mandel
|Will draw a mandelbrot set in 3 hours, more useful as a stability test than a useful fractal program
|Mu0n
|basic
|https://github.com/Mu0n/F256KbasicBASICdoodles?tab=readme-ov-file#fractal
|-
|mariobros
|Tilemap and platformer test based on Mario Bros. (1983)
|beethead
|pgz
|https://github.com/noyen1973/mariobros
|-
|pendulum
|Sprite and MIDI demo
|MikeC
|pgz
|https://github.com/mcassera/pendulum
|-
|wormhole
|Shows a fast wireframe animation of a wormhole
|haydenkale
|pgz or bin at $0000
|https://github.com/clandrew/wormhole?tab=readme-ov-file
|}

== Games ==

{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|bbombers
|Boulder Bombers (Alpha-2) Clone of Canyon Bombers
|Scott (xDraconian)
|pgx
atari joystick
|https://github.com/scttgs0/BoulderBombers<nowiki/>https://github.com/scttgs0/BoulderBombers/releases/tag/alpha_2
|-
|Bombsweeper
|Bomb sweeper port
|beethead
|pgz
|https://discord.com/channels/691915291721990194/855689509520932885/1196352934083035156
|-
|Cosmic
|Shoot 'em up
|beethead
|pgz
|https://discordapp.com/channels/691915291721990194/1054250238308790342/1175982979537969214
|-
|F256-Trek
|Updated Trek, with modern F256 Graphics
|econtrerasd
|basic
|[https://github.com/econtrerasd/Trek-F256/releases/tag/v1.0 https://github.com/econtrerasd/Trek-F256/releases]
|-
|F256 two to the power of eleven
|Port of the puzzle game of 2048
|mgr42
|pgz
|https://github.com/rmsk2/F256_2048<nowiki/>
|-
|fillerup
|Fill 'er Up (WIP)
Qix-like game
|Scott (xDraconian)
|pgx
atari joystick
|https://github.com/scttgs0/Fill-er-up
|-
|FusionDrive
|An outrun type game that also plays a MIDI soundtrack
|Mu0n
|pgz
|wip v0.2, can use a NES pad #1 to move around, or left/right arrow keys currently https://github.com/Mu0n/F256KsimpleCdoodles/tree/main/NoFussDemos
|-
|jewelkeeper
|Sokoban port
|beethead
|pgz
|https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/apps/jewelkeeper.pgz<nowiki/>You can now specify a level file when loading the game <code>/- jewelkeeper.pgz <levels.txt></code>. Find more levels at https://www.sourcecode.se/sokoban/levels.php. Keep in mind the maximum level dimension is 20x15, anything larger will be ignored
|-
|Jr Wördl
|port of Wordle
|AgeAgeEye
|basic
|https://github.com/ageageeye/Superbasic-F256Jr-examples
|-
|kartdemo
|Kart racing game
|SprySloth
|pgz
|https://discord.com/channels/691915291721990194/1225217654487253094/1228246780840513556
|-
|Lair of the Lich King
|Rogue like dungeon crawler. Demo has 3 levels; full has 25+
|Micah
| - lkdemo/lk.pgz
|[https://discord.com/channels/691915291721990194/1230670413361844244/1317256215566487593 1.0 Beta 19 Demo]
|-
|livewire
|Livewire (WIP)
Tempest-like game
|Scott (xDraconian)
|pgx
atari joystick
|https://github.com/scttgs0/Livewire
|-
|Maze-Munch
|Pac-Man clone
|SprySloth
|pgz
|https://github.com/cmassat/Maze-Munch
|-
|pdefense
|Planetary Defense (WIP)
|Scott (xDraconian)
|pgx
mouse
atari joystick
|https://github.com/scttgs0/PlanetaryDefense
|-
|Shanghai/Mahjongg
|A clone of Shanghai. Also known as Mahjongg
|mgr42
|pgz or KUP
mouse needed
|https://github.com/rmsk2/f256_mahjong
|-
|Ski-Jr
|Ski game downhill
|digarok
|basic
|https://github.com/digarok/superbasic-traveler/blob/main/ski-jr.bas
|-
|Track & Field
|Olympic Game by Konami (WIP)
|Scott (xDraconian)
|pgz
atari joystick or keyboard
|
|-
|Tetris
|Good old 80's game
|Daniel Tremblay (Grenouye)
|pgz
atari joystick or keyboard
|https://github.com/dtremblay/c256-tetris/tree/f256k
|}

== Game Jam #01 - April 6th/7th 2024 ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|15puzzle
|Number sort puzzle
|mgr42
|pgz
|https://github.com/rmsk2/f256_15puzzle/releases<nowiki/>
|-
|Flight Simulator
|flying simulator
|sduensin
|pgz
|https://cdn.discordapp.com/attachments/1225481966200029286/1227764847819620454/shotel.pgz
|-
|frisbee
|Frisbee throw past sport game
|dwsJason
|pgz
|https://github.com/dwsJason/f256/blob/develop/merlin32/frisbee/frisbee.pgz
|-
|Impasse
|Shoot 'em up
|digarok
|pgz
|https://discord.com/channels/691915291721990194/1225481966200029286/1227075699895046235
|-
|soccur
|mutliplayer game of soccer
|beethead
|pgz
|executable:https://discord.com/channels/691915291721990194/1225481966200029286/1226808228948611184
source code:
https://discord.com/channels/691915291721990194/1225481966200029286/1226812472069980232
|-
|Trek
|port of classic Star Trek game
|contrerasd
|basic
|https://discord.com/channels/691915291721990194/1225481966200029286/1226727849944289341
|-
|Typing Star
|typing reaction game
|haydenkale
|pgz
|https://github.com/clandrew/typestar
|-
|}

== Game Jam #02 - October 25th-November 1st 2024 ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|Bach's MIDI Hero
|Free MIDI/PSG play + note play tutorial
|Mu0n
|pgz
the MIDI feature requires a F256K2 or F256Jr2; a legacy PSG option also allows F256K and F256Jr to still hear it. Optionally uses a MIDI in controller plugged in.
|https://github.com/Mu0n/F256KsimpleCdoodles/releases/download/v1.2/BachHero.pgz
|-
|f256_snake
|
|mgr42
|pgz. Use cursor keys, Atari joystick or SNES pad to play
|https://github.com/rmsk2/f256_snake
|-
|fnxsnake
|
|silk-neon
|pgz
|https://github.com/ksiondag/fnxsnake
|-
|The Hallow
|
|beethead
|pgz
|https://github.com/noyen1973/FoenixGameJamOct2024
|-
|Halloween Birthday
|
|SprySloth
|pgz
|https://github.com/cmassat/GameJam2024_F256K
|-
|Haunted Mansion
|
|digarok
|superbasic
|https://github.com/digarok/fnxgamejam-haunted-mansion
|-
|Kooyan
|
|Grenouye
|pgz
|https://github.com/dtremblay/kooyan.git
|-
|Spooky Run
|
|dwsJason
|pgz
|https://github.com/dwsJason/spooky
|-
|Trick or Treat
|
|Mike
|pgz
|https://github.com/mcassera/TrickOrTreat
|-
|Ultima III - Exodus
|port
|Minstrel Dragon
|pgz
|https://github.com/minstreldragon/F256_Ultima_3
|-
|Warlock
|remake of 68000 game
|xDraconian
|pgz
atari joystick
DOWN=change_level
UP=jump
UP-LEFT=leap
UP-RIGHT=leap
|https://github.com/scttgs0/Foenix_GameJam_Oct2024
|}

== Game Jam #03 - April 18th-April 27th 2025 ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|Arcade Shanghai v1.2
|Shanghai clone
|contrerasd
|basic, keep the .bas program in root, the rest in the provided ashanghai/ folder
|https://github.com/econtrerasd/ashanghai/releases
|-
|Bawk Bawk Cluck Cluck
|Chicken themed platformer
|beethead
|pgz
|https://github.com/noyen1973/FoenixGameJamApr2025
|-
|BitLadder
|Shoot 'Em Up
|Mu0n
|pgz. For full sound compatibility, a Jr2 or K2 is needed.
Uses 4 sound chips! (PSG, SID, OPL3, MIDI)
|https://mu0n.itch.io/bitladder
|-
|F256_Commando
|Commando port
|SprySloth
|pgz
|https://github.com/cmassat/F256_Commando
|-
|F256_LodeRunner
|Lode Runner port
|Minstrel Dragon
|pgz
|https://github.com/minstreldragon/F256_Loderunner/releases
|-
|Mahjong
|Shangai clone
|mgr42
|pgz
|https://github.com/rmsk2/f256_mahjong/releases
|-
|Quarth
|Block placement arcade game
|Grenouye
|pgz
|https://grenouye.itch.io/f256-quarth
|-
|Skee(ster)-Ball
|
|Mike
|pgz
|https://github.com/mcassera/skeeball256/tree/main
|}

== Game Jam #04 - November-December 2025 ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|Fallitaire
|A cozy fall-themed twist on Pyramid Solitaire, built for the Foenix F256K2 Game Jam!
|Programmer Vs World
|bas
|https://programmervsworld.itch.io/fallitaire
|-
|H.E.R.O.
|Port of the classic game H.E.R.O.
|Cibee
|pgz
|https://c1bee.itch.io/hero
|-
|Leaderboard
|Golf game
|xDraconian
|pgz
|https://discord.com/channels/691915291721990194/1424187774642290799/1456104940186501132
|-
|Pitfall
|Port of the classic Pitfall game from Activision
|MinstrelDragon
|pgz
|https://minstrel.itch.io/pitfall-foenix-f256x
|-
|Return of the Falcon
|
|Callisto
|TBD
|
|-
|Swicheroo
|An Alternate Puzzle Game
|jbaker8935
|pgz
|https://jbaker8935.itch.io/switcheroo
|-
|Track Day
|v1.0 top down race game vs computer controlled opponents
|MikeC
|pgz
|https://mcassera.itch.io/track-day-racing
|}

== Music ==

{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|cozyMIDI
|Plays a SMF with the SAM2695 or VS1053b
|Mu0n
|pgz
|cozyMIDI v2.5 can open and play type 0 and type 1 standard MIDI files (SMF)
needs a Jr2 or K2
with a 2x core at https://github.com/Mu0n/F256KsimpleCdoodles/tree/main/NoFussDemos

run operation 1: just as itself, it will force you to pick a midi file in the 'midi/' folder /- cozymidi

run operation 2: in f/manager, if you put this as <code>midiplayer.pgz</code>in the '_apps/' folder, f/manager will open midi file with it when you launch .mid files.

Program link: https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/cozymidi.pgz
|-
|digestMidi
|converts .mid to .dim
|Mu0n
|pgz
|.mid files are slow to load, parse and prepare for a playback. This tool comes in to convert them into a .dim format that strips out unnecessary MIDI commands and sets it up for timer0 time delays. Works with type 0 and type 1 standard midi files. This tools does the conversion and lets you hear the result.
Find the latest version here: https://github.com/Mu0n/F256MiscGoodies/tree/main/apps
|-
|EdInHisLib
|SID+OPL3 simultaneously
|beethead, ported from xantax
|pgz
|F256 port: https://discordapp.com/channels/691915291721990194/1054249926521016392/1184413356598231120
original: <nowiki>https://csdb.dk/release/?id=170898</nowiki>. Not 100% accurate but close.
|-
|F256amp
|mp3, ogg, wav, wma file playback
|Mu0n
|pgz
|(aka audioplayer.pgz) v2.3 Needs a Jr.2 or K2 since it uses the VS1053b chip.
For a starter collection of .mp3 and other audio files, check the SD curated collection here: https://github.com/Mu0n/F256MiscGoodies/tree/main/SDCard_Collection
run operation 1: just as itself, it will force you to pick an audio file. it expects a <code>media/mp3/</code> folder, but it can live without it and peek into the root instead.

run operation 2: with an argument, it will auto-play it: /- f256amp yourmp3file.mp3

run operation 3: in f/manager, if you put this as <code>audioplayer.pgz</code> in the '_apps/' folder. This lets f/manager automatically open up .mp3, .wav, .ogg, .wma that you press enter on.

Program link: https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/f256amp.pgz
|-
|FireJam
|all chips, music playing with MIDI in
|Mu0n
|pgz
|v1.2 MIDI in and out capable, it will still partially work with a Jr. (PSG, and SID if you have them), a K (PSG, SID, OPL3) and the newest wave 2 Jr2 and K2 (PSG, SID, OPL3, SAM, VS1053b).
Best to use with a MIDI in controller, but it'll be controllable with arrows and space to make notes individually, or the F keys to start beats. https://github.com/Mu0n/F256KsimpleCdoodles/tree/main/NoFussDemos
|-
|jrtracker
|Tracker based in basic and uses the PSG
(considered obsolete, use tracker2)
|contrerasd
|basic
|https://ptb.discord.com/channels/691915291721990194/1008139105386889346/1188292876984143983
|-
|modo
|MOD player using the PSG
|dwsJason and digarok
|pgz
|https://discordapp.com/channels/691915291721990194/855689509520932885/1190723114661859429
|-
|Musik
|Music piece demo using MIDI
|Mike
|pgz
|https://github.com/mcassera/Musik/blob/main/Musik.PGZ<nowiki/>Musikalisches Würfelspiel
Requires a Jr2 or K2 since it uses MIDI
|-
|opl3snooper
|playback of VGM files (that use opl2 and opl3) and MIDI in
|Mu0n
|pgz
|v1.1 mainly plays back vgm files, but you can pause it and snoop around the channel instruments and play up to 18 note polyphony with MIDI in. expects a collection in media/vgm/, or it will browse from the root if it can't find.
It can load a .spl (Simple PLaylist) text file, which is one file per line, including their respective paths.
Requires a Jr2 or K2 with a 2x core to use the extra bank of SRAM.
For a starter collection of .vgm files, check the SD curated collection here: https://github.com/Mu0n/F256MiscGoodies/tree/main/SDCard_Collection
run operation 1: just as itself, it will force you to pick a midi file in the 'media/vgm/' folder

run operation 2: in f/manager (v1.1b9 and up), if you put this as <code>vgmplayer.pgz</code>in the '_apps/' folder, f/manager will open midi file with it when you launch .vgm files.

Program link: https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/opl3snooper.pgz
|-
|opl3tweak
|uses MIDI in, plays 18 channels polyphony in real time to the YMF262 OPL3. Fish for random register values.
|Mu0n
|pgz
|v0.1. Can't save or load instrument definitions yet. Needs a K2 with a MIDI in currently. https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/opl3tweak.pgz
Arrows to move around, + and - keys to incr/decr values or type in a hex value directly under the highlighted position.
|-
|piano
|Plays some PSG notes with the keyboard
|Mu0n
|basic
|https://github.com/Mu0n/F256KbasicBASICdoodles?tab=readme-ov-file#pulse-sound-generator-piano
|-
|playvgm
|plays a headless vgm file with OPL3
|G33kyAndIKnowIt
|pgx
|https://github.com/natebarney/playvgm-f256k
some example music files can be gotten from this post:
[https://discord.com/channels/691915291721990194/975117322836656138/1220366429640065074 https://discord.com/channels/6][https://discord.com/channels/691915291721990194/975117322836656138/1220366429640065074 91915291721990194/975117322836656138/1220366429640065074]

1) open a normal .vgm into a hex editor <nowiki/>and cut out the header bytes from 0x00 to 0x<nowiki/>FF

2) run by first using superbasic's '''''bload''''' '''''"yourmusicfile", $01000'''''
followed by running this program with '''''/- playvgm.pgx'''''
|-
|sidtweak
|uses MIDI in, plays 6 channels polyphony in real time to the dual SID. Fish for random register values.
|Mu0n
|pgz
|v0.1. Can't save or load instrument definitions yet. Needs a K2 with a MIDI in currently. https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/sidtweak.pgz
Arrows to move around, + and - keys to incr/decr values or type in a hex value directly under the highlighted position.
|-
|rawsidplayer
|plays raw PSID files from the HVSC collection, converted by zigreSID
|Mu0n
|pgz
|(formely psidplayer) v0.2 find rawsidplayer.pgz and a starter .rsd file (raw sid dumps). For a starter collection of .rsd files, check the SD curated collection here: https://github.com/Mu0n/F256MiscGoodies/tree/main/SDCard_Collection
extract sid.zip into a folder /sid/ in the root of your SD card, that's where psidplayer.pgz will first look to let you pick a file. failing that, it will fall back to the root folder and let you navigate.

program link:

https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/rawsidplayer.pgz
|-
|tracker2 v1.5
|Like jrtracker.bas, but using both PSGs
|contrerasd
|basic
|https://github.com/econtrerasd/Tracker2/releases
|}

== Uti<nowiki/>lities ==

{| class="wikitable"
|+
!Program
!Descrip<nowiki/>tion
!Author
!Notes on running
!Link
|-
|basic2text
|A simple utility for translating Commodore BASIC (all variants) from its native tokenized file format to a text format that can be opened with SuperBASIC. Does not perform any code translation: all adaptation is up to you.
|Micah
|pgZ
|https://github.com/WartyMN/F256-BasText/releases/latest
|
|-
|dcopy
|A tool to copy files from one drive to another or to/from your PC via RS-232 and a nullmodem cable
|mgr42
|pgz/flash
|https://github.com/rmsk2/f256_dcopy
|
|-
|f/manager
|A general file utility, launcher, and memory viewing program. Dual-panel file/memory browsers; copy between disks, between folders on same disk, and from memory to disk and vice versa; delete, rename, and duplicate files; view files as hex or text (with word-wrap); launch applications and known file types; set the RTC clock; search in RAM and flash. Works with internal SD card and IEC devices such as FNX1591 and Commodore 1541. Can be installed in primary flash position ahead of SuperBASIC or DOS, or at a higher location. Can also be run from disk with "- fm.pgz".
|Micah
|pgZ/flash
|https://github.com/WartyMN/F256-FileManager/releases
|
|-
|f256_reset
|A small utility that lets you reset the machine through this piece of flash software
|mgr42
|flash
|https://github.com/rmsk2/f256_reset
|
|-
|fcart
|A program that allows to write data to flash expansion cartridges
|mgr42
|pgz, on-board and cartridge flash
|https://github.com/rmsk2/cartflash
|
|-
|flashcart
|Allows to wipe a block of flash or write a program to a flash cart, from this basic program from the F256Jr/K
|redfool.
|basic
|https://github.com/Red-Fool/F256_FlashCart/tree/main
|
|-
|flashselect
|Allows to select a program to start from a flash cartridge via a menu
|mgr42
|pgz, on-board and cartridge flash
|https://github.com/rmsk2/flashselect
|
|-
|fonts
|A variety of fonts using the standard F256 character set arrangement. Load with the F256 file manager (f/manager), or your own code.
|Micah
|(not a program)
|[https://github.com/WartyMN/Foenix-Fonts/tree/main https://github.com/WartyMN/Foenix-Fonts]
|
|-
|midiStuff
|Test program for a F256K2 or F256Jr2 that sends MIDI data to the internal sam2695 dream chip that produces MIDI based audio. Also test a keyboard controller plugged in the MIDI in port.
|Mu0n
|pgz
|https://github.com/Mu0n/F256KsimpleCdoodles/blob/main/README.md#midistuff
|
|-
|moreorless
|A text editor for the Foenix 256 line of computers
|mgr42
|pgz
|https://github.com/rmsk2/moreorless/releases/
|
|-
|pgz2flash
|A program for your Linux, Windows or MacOS machine to turn any PGZ or SuperBASIC program into a KUP which can be run from cartridge or onboard flash memory
|mgr42
|Executable for modern computers
|https://github.com/rmsk2/pgz2flash
|
|-
|sidTester
|Simple superbasic program that tests out all 3 voices of the SID1 on the Jr (if populated), K, Jr2 and K2. Ported by Mu0n, made by andy on HackJunk.com https://hackjunk.com/2017/11/07/commodore-64-sid-tester/
|andy
|basic
|https://github.com/Mu0n/F256MiscGoodies/blob/main/apps/sidtester.bas
|
|-
|testsuite.bas
|a series of tests for your F256, video modes and sound chips
|econtrerasd
|basic
|run from the root,
https://github.com/econtrerasd/testSuite-F256/releases
|
|-
|wget<nowiki/>
|<nowiki/>fetches a file from a http address if you have a network connection active. Works with the K and Jr. ESP32 Feather 'huzzah' board. Not meant to be used with the K2 and Jr2 Wiznet chip.
|gadget
|<nowiki/>pgz/flash
|https://github.com/ghackwrench/F256_wget
|
|}

== Sample Code ==

{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|Assembly examples
|Sample programs for several features of the Foenix F256K and Jr.
|mgr42
|read github
|https://github.com/rmsk2/Hello_Foenix256_Jr/blob/main/testprogs.md
|-
|cc65 example
|c example code
|gadget
|read github
|https://github.com/ghackwrench/F256_Jr_Kernel_DOS
|-
|digarok basic stuff
|Lots of basic examples
|digarok
|read github
|https://github.com/digarok/superbasic-traveler/tree/main
|-
|Mu0n's F256K asm doodles
|Some asm examples
|Mu0n
|read github
|https://github.com/Mu0n/F256KsimpleASMdoodles
|-
|Mu0n's F256K basic doodles
|Some basic examples
|Mu0n
|read github
|https://github.com/Mu0n/F256KbasicBASICdoodles
|-
|Mu0n's F256K C doodles
|Some C examples
|Mu0n
|read github
|https://github.com/Mu0n/F256KsimpleCdoodles
|-
|Raúl SQ basic repo
|F256 SuperBASIC Trigonometry
|Raúl SQ
|basic
|https://github.com/raul-sq/FoenixF256K2
|-
|tcp example
|connects to a server and gets typed in text echoed back to you
|gadget
|$2000
|https://github.com/ghackwrench/F256_example_tcp
|}

Software for 6502

2026-01-07T18:42:37Z

1BitFeverDreams: /* Music */ cozymidi v2.5

Note that when an hex address is given, it's meant to instruct as to which address to bload or to send (ie foenixmgr python script) the program (ie a .bin file) to before running it. For extra help on how to run .bin files and almost every possible scheme that has to be used to run program, you can consult this video that's also part of [[Getting Started]], this one: https://www.youtube.com/watch?v=0ShFv89KGDs

Many download links are posts in the main [https://discord.gg/9vjUEGgcUS Foenix Retro Systems discord server] which will require you to join in order to get to them.

A [[Getting Started#Demos Archive|Demo Archive]] was put together in September 2023 to get ready to show to youtubers, some of these are linked once more, in this page.

There's also the Foenix Marketplace website maintained by EMWhite with its own collection of articles and software http://apps.emwhite.org/foenixmarketplace/.

===== Curated SD card collection of games, demos, utilities =====
Here is a download link to a zip file meant to be extracted into the root of an SD card: https://github.com/Mu0n/F256MiscGoodies/tree/main/SDCard_Collection

Best to wipe out your SD card and start anew with the contents of this extracted to root. Micah's file manager doesn't like long lists of files so it really is best to not overdo it. I tried to minimize the files in root, but I couldn't for everything.

Open the readme.txt file with moreorless to see some instructions about the collection. Best to run /- fm first, then open the readme.txt from it

== Applications ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|F256 f/term
|Terminal emulator for F256K and Jr with classic (flat) memory load
|Micah
| - fterm.pgZ or use f/manager
|https://github.com/WartyMN/F256-terminal/blob/main/release/fterm.pgZ
|-
|FoenixTarot
|Tarot card readings in SuperBasic
|Mike
|basic
|https://github.com/mcassera/FoenixTarot/tree/main
|-
|Forthf256
|Forth implementation
|Vasyl
|pgz in its forth/ folder
|https://github.com/VasylTsv/ForthX16
|-
|WildBits Graphic Toolkit
|(fmr. F256-GraphicToolkit) Sprite editor, Tilemap editor, Font editor + misc tools
|econtrerasd
|basic
|https://github.com/econtrerasd/F256-GraphicToolkit/releases
|}

== Demos ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|badapple
|A 80x60 textmode port of Bad Apple, uses the VS1053b for quality mp3 audio. Needs a Jr2 or K2!
|Mu0n
|pgz*
|*unzip badapple.zip into the root of your SD card. If done right, the 3 files within will be in the demos/ folder. The program expects its data file there when it runs. https://github.com/Mu0n/F256MiscGoodies/blob/main/apps/badapple.zip
|-
|balls
|Draw a good quantity of multiplexed sprites, fast. Balls bouncing around
|celton
|pgz
|https://github.com/FoenixRetro/demos/blob/main/MultiplexedSprites.md
|-
|F256Archon
|Splash screen intro, plays MIDI using the SAM2695, requires a K2 or Jr2
|Mu0n
|pgz
|https://github.com/Mu0n/F256Archon/releases
|-
|f256_life
|An implementation of Conway's game of life
|mgr42
|pgz
|https://github.com/rmsk2/f256_life
|-
|F256 Mandelbrot
|Draws Mandelbrot set fast (5 mins) using coprocessor math. Allows to zoom into the set.
|mgr42
|uses basic loader
|https://github.com/rmsk2/F256_Mandelbrot
|-
|F256ShowCase
|Shows sliding tiling graphics, moves with joystick
|eriktier
|$0000
|https://github.com/pig-games/F256Showcase
|-
|fnxmas23
|PSG mod music, scrolling text, sound effects, must see demo!
|dwsJason and digarok
|pgz
|https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/apps/xmas24_k2.pgz revised version that can run on wave 2 Jr2 and K2 as well
|-
|foenixmas23
|Xmas 2023 demo with SID music from the classic 1983 C64 xmas demo
|EMWhite
|uses basic loader
|http://apps.emwhite.org/shared-files/815/?foenixmas23.zip
|-
|livingworlds
|Living Worlds, a port of a color cycling by Mark Ferrari, ported here on the F256 by haydenkale
|haydenkale
|$0000
|https://github.com/clandrew/livingworlds/tree/e4532e0d530b76ccb90368fdf5ad10bfa2deeb12
|-
|mandel
|Will draw a mandelbrot set in 3 hours, more useful as a stability test than a useful fractal program
|Mu0n
|basic
|https://github.com/Mu0n/F256KbasicBASICdoodles?tab=readme-ov-file#fractal
|-
|mariobros
|Tilemap and platformer test based on Mario Bros. (1983)
|beethead
|pgz
|https://github.com/noyen1973/mariobros
|-
|wormhole
|Shows a fast wireframe animation of a wormhole
|haydenkale
|pgz or bin at $0000
|https://github.com/clandrew/wormhole?tab=readme-ov-file
|}

== Games ==

{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|bbombers
|Boulder Bombers (Alpha-2) Clone of Canyon Bombers
|Scott (xDraconian)
|pgx
atari joystick
|https://github.com/scttgs0/BoulderBombers<nowiki/>https://github.com/scttgs0/BoulderBombers/releases/tag/alpha_2
|-
|Bombsweeper
|Bomb sweeper port
|beethead
|pgz
|https://discord.com/channels/691915291721990194/855689509520932885/1196352934083035156
|-
|Cosmic
|Shoot 'em up
|beethead
|pgz
|https://discordapp.com/channels/691915291721990194/1054250238308790342/1175982979537969214
|-
|F256-Trek
|Updated Trek, with modern F256 Graphics
|econtrerasd
|basic
|[https://github.com/econtrerasd/Trek-F256/releases/tag/v1.0 https://github.com/econtrerasd/Trek-F256/releases]
|-
|F256 two to the power of eleven
|Port of the puzzle game of 2048
|mgr42
|pgz
|https://github.com/rmsk2/F256_2048<nowiki/>
|-
|fillerup
|Fill 'er Up (WIP)
Qix-like game
|Scott (xDraconian)
|pgx
atari joystick
|https://github.com/scttgs0/Fill-er-up
|-
|FusionDrive
|An outrun type game that also plays a MIDI soundtrack
|Mu0n
|pgz
|wip v0.2, can use a NES pad #1 to move around, or left/right arrow keys currently https://github.com/Mu0n/F256KsimpleCdoodles/tree/main/NoFussDemos
|-
|jewelkeeper
|Sokoban port
|beethead
|pgz
|https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/apps/jewelkeeper.pgz<nowiki/>You can now specify a level file when loading the game <code>/- jewelkeeper.pgz <levels.txt></code>. Find more levels at https://www.sourcecode.se/sokoban/levels.php. Keep in mind the maximum level dimension is 20x15, anything larger will be ignored
|-
|Jr Wördl
|port of Wordle
|AgeAgeEye
|basic
|https://github.com/ageageeye/Superbasic-F256Jr-examples
|-
|kartdemo
|Kart racing game
|SprySloth
|pgz
|https://discord.com/channels/691915291721990194/1225217654487253094/1228246780840513556
|-
|Lair of the Lich King
|Rogue like dungeon crawler. Demo has 3 levels; full has 25+
|Micah
| - lkdemo/lk.pgz
|[https://discord.com/channels/691915291721990194/1230670413361844244/1317256215566487593 1.0 Beta 19 Demo]
|-
|livewire
|Livewire (WIP)
Tempest-like game
|Scott (xDraconian)
|pgx
atari joystick
|https://github.com/scttgs0/Livewire
|-
|Maze-Munch
|Pac-Man clone
|SprySloth
|pgz
|https://github.com/cmassat/Maze-Munch
|-
|pdefense
|Planetary Defense (WIP)
|Scott (xDraconian)
|pgx
mouse
atari joystick
|https://github.com/scttgs0/PlanetaryDefense
|-
|Shanghai/Mahjongg
|A clone of Shanghai. Also known as Mahjongg
|mgr42
|pgz or KUP
mouse needed
|https://github.com/rmsk2/f256_mahjong
|-
|Ski-Jr
|Ski game downhill
|digarok
|basic
|https://github.com/digarok/superbasic-traveler/blob/main/ski-jr.bas
|-
|Track & Field
|Olympic Game by Konami (WIP)
|Scott (xDraconian)
|pgz
atari joystick or keyboard
|
|-
|Tetris
|Good old 80's game
|Daniel Tremblay (Grenouye)
|pgz
atari joystick or keyboard
|https://github.com/dtremblay/c256-tetris/tree/f256k
|}

== Game Jam #01 - April 6th/7th 2024 ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|15puzzle
|Number sort puzzle
|mgr42
|pgz
|https://github.com/rmsk2/f256_15puzzle/releases<nowiki/>
|-
|Flight Simulator
|flying simulator
|sduensin
|pgz
|https://cdn.discordapp.com/attachments/1225481966200029286/1227764847819620454/shotel.pgz
|-
|frisbee
|Frisbee throw past sport game
|dwsJason
|pgz
|https://github.com/dwsJason/f256/blob/develop/merlin32/frisbee/frisbee.pgz
|-
|Impasse
|Shoot 'em up
|digarok
|pgz
|https://discord.com/channels/691915291721990194/1225481966200029286/1227075699895046235
|-
|soccur
|mutliplayer game of soccer
|beethead
|pgz
|executable:https://discord.com/channels/691915291721990194/1225481966200029286/1226808228948611184
source code:
https://discord.com/channels/691915291721990194/1225481966200029286/1226812472069980232
|-
|Trek
|port of classic Star Trek game
|contrerasd
|basic
|https://discord.com/channels/691915291721990194/1225481966200029286/1226727849944289341
|-
|Typing Star
|typing reaction game
|haydenkale
|pgz
|https://github.com/clandrew/typestar
|-
|}

== Game Jam #02 - October 25th-November 1st 2024 ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|Bach's MIDI Hero
|Free MIDI/PSG play + note play tutorial
|Mu0n
|pgz
the MIDI feature requires a F256K2 or F256Jr2; a legacy PSG option also allows F256K and F256Jr to still hear it. Optionally uses a MIDI in controller plugged in.
|https://github.com/Mu0n/F256KsimpleCdoodles/releases/download/v1.2/BachHero.pgz
|-
|f256_snake
|
|mgr42
|pgz. Use cursor keys, Atari joystick or SNES pad to play
|https://github.com/rmsk2/f256_snake
|-
|fnxsnake
|
|silk-neon
|pgz
|https://github.com/ksiondag/fnxsnake
|-
|The Hallow
|
|beethead
|pgz
|https://github.com/noyen1973/FoenixGameJamOct2024
|-
|Halloween Birthday
|
|SprySloth
|pgz
|https://github.com/cmassat/GameJam2024_F256K
|-
|Haunted Mansion
|
|digarok
|superbasic
|https://github.com/digarok/fnxgamejam-haunted-mansion
|-
|Kooyan
|
|Grenouye
|pgz
|https://github.com/dtremblay/kooyan.git
|-
|Spooky Run
|
|dwsJason
|pgz
|https://github.com/dwsJason/spooky
|-
|Trick or Treat
|
|Mike
|pgz
|https://github.com/mcassera/TrickOrTreat
|-
|Ultima III - Exodus
|port
|Minstrel Dragon
|pgz
|https://github.com/minstreldragon/F256_Ultima_3
|-
|Warlock
|remake of 68000 game
|xDraconian
|pgz
atari joystick
DOWN=change_level
UP=jump
UP-LEFT=leap
UP-RIGHT=leap
|https://github.com/scttgs0/Foenix_GameJam_Oct2024
|}

== Game Jam #03 - April 18th-April 27th 2025 ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|Arcade Shanghai v1.2
|Shanghai clone
|contrerasd
|basic, keep the .bas program in root, the rest in the provided ashanghai/ folder
|https://github.com/econtrerasd/ashanghai/releases
|-
|Bawk Bawk Cluck Cluck
|Chicken themed platformer
|beethead
|pgz
|https://github.com/noyen1973/FoenixGameJamApr2025
|-
|BitLadder
|Shoot 'Em Up
|Mu0n
|pgz. For full sound compatibility, a Jr2 or K2 is needed.
Uses 4 sound chips! (PSG, SID, OPL3, MIDI)
|https://mu0n.itch.io/bitladder
|-
|F256_Commando
|Commando port
|SprySloth
|pgz
|https://github.com/cmassat/F256_Commando
|-
|F256_LodeRunner
|Lode Runner port
|Minstrel Dragon
|pgz
|https://github.com/minstreldragon/F256_Loderunner/releases
|-
|Mahjong
|Shangai clone
|mgr42
|pgz
|https://github.com/rmsk2/f256_mahjong/releases
|-
|Quarth
|Block placement arcade game
|Grenouye
|pgz
|https://grenouye.itch.io/f256-quarth
|-
|Skee(ster)-Ball
|
|Mike
|pgz
|https://github.com/mcassera/skeeball256/tree/main
|}

== Game Jam #04 - November-December 2025 ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|Fallitaire
|A cozy fall-themed twist on Pyramid Solitaire, built for the Foenix F256K2 Game Jam!
|Programmer Vs World
|bas
|https://programmervsworld.itch.io/fallitaire
|-
|H.E.R.O.
|Port of the classic game H.E.R.O.
|Cibee
|pgz
|https://c1bee.itch.io/hero
|-
|Leaderboard
|Golf game
|xDraconian
|pgz
|https://discord.com/channels/691915291721990194/1424187774642290799/1456104940186501132
|-
|Pitfall
|Port of the classic Pitfall game from Activision
|MinstrelDragon
|pgz
|https://minstrel.itch.io/pitfall-foenix-f256x
|-
|Return of the Falcon
|
|Callisto
|TBD
|
|-
|Swicheroo
|An Alternate Puzzle Game
|jbaker8935
|pgz
|https://jbaker8935.itch.io/switcheroo
|-
|Track Day
|v1.0 top down race game vs computer controlled opponents
|MikeC
|pgz
|https://mcassera.itch.io/track-day-racing
|}

== Music ==

{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|cozyMIDI
|Plays a SMF with the SAM2695 or VS1053b
|Mu0n
|pgz
|cozyMIDI v2.5 can open and play type 0 and type 1 standard MIDI files (SMF)
needs a Jr2 or K2
with a 2x core at https://github.com/Mu0n/F256KsimpleCdoodles/tree/main/NoFussDemos

run operation 1: just as itself, it will force you to pick a midi file in the 'midi/' folder /- cozymidi

run operation 2: in f/manager, if you put this as <code>midiplayer.pgz</code>in the '_apps/' folder, f/manager will open midi file with it when you launch .mid files.

Program link: https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/cozymidi.pgz
|-
|digestMidi
|converts .mid to .dim
|Mu0n
|pgz
|.mid files are slow to load, parse and prepare for a playback. This tool comes in to convert them into a .dim format that strips out unnecessary MIDI commands and sets it up for timer0 time delays. Works with type 0 and type 1 standard midi files. This tools does the conversion and lets you hear the result.
Find the latest version here: https://github.com/Mu0n/F256MiscGoodies/tree/main/apps
|-
|EdInHisLib
|SID+OPL3 simultaneously
|beethead, ported from xantax
|pgz
|F256 port: https://discordapp.com/channels/691915291721990194/1054249926521016392/1184413356598231120
original: <nowiki>https://csdb.dk/release/?id=170898</nowiki>. Not 100% accurate but close.
|-
|F256amp
|mp3, ogg, wav, wma file playback
|Mu0n
|pgz
|(aka audioplayer.pgz) v2.3 Needs a Jr.2 or K2 since it uses the VS1053b chip.
For a starter collection of .mp3 and other audio files, check the SD curated collection here: https://github.com/Mu0n/F256MiscGoodies/tree/main/SDCard_Collection
run operation 1: just as itself, it will force you to pick an audio file. it expects a <code>media/mp3/</code> folder, but it can live without it and peek into the root instead.

run operation 2: with an argument, it will auto-play it: /- f256amp yourmp3file.mp3

run operation 3: in f/manager, if you put this as <code>audioplayer.pgz</code> in the '_apps/' folder. This lets f/manager automatically open up .mp3, .wav, .ogg, .wma that you press enter on.

Program link: https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/f256amp.pgz
|-
|FireJam
|all chips, music playing with MIDI in
|Mu0n
|pgz
|v1.2 MIDI in and out capable, it will still partially work with a Jr. (PSG, and SID if you have them), a K (PSG, SID, OPL3) and the newest wave 2 Jr2 and K2 (PSG, SID, OPL3, SAM, VS1053b).
Best to use with a MIDI in controller, but it'll be controllable with arrows and space to make notes individually, or the F keys to start beats. https://github.com/Mu0n/F256KsimpleCdoodles/tree/main/NoFussDemos
|-
|jrtracker
|Tracker based in basic and uses the PSG
(considered obsolete, use tracker2)
|contrerasd
|basic
|https://ptb.discord.com/channels/691915291721990194/1008139105386889346/1188292876984143983
|-
|modo
|MOD player using the PSG
|dwsJason and digarok
|pgz
|https://discordapp.com/channels/691915291721990194/855689509520932885/1190723114661859429
|-
|Musik
|Music piece demo using MIDI
|Mike
|pgz
|https://github.com/mcassera/Musik/blob/main/Musik.PGZ<nowiki/>Musikalisches Würfelspiel
Requires a Jr2 or K2 since it uses MIDI
|-
|opl3snooper
|playback of VGM files (that use opl2 and opl3) and MIDI in
|Mu0n
|pgz
|v1.1 mainly plays back vgm files, but you can pause it and snoop around the channel instruments and play up to 18 note polyphony with MIDI in. expects a collection in media/vgm/, or it will browse from the root if it can't find.
It can load a .spl (Simple PLaylist) text file, which is one file per line, including their respective paths.
Requires a Jr2 or K2 with a 2x core to use the extra bank of SRAM.
For a starter collection of .vgm files, check the SD curated collection here: https://github.com/Mu0n/F256MiscGoodies/tree/main/SDCard_Collection
run operation 1: just as itself, it will force you to pick a midi file in the 'media/vgm/' folder

run operation 2: in f/manager (v1.1b9 and up), if you put this as <code>vgmplayer.pgz</code>in the '_apps/' folder, f/manager will open midi file with it when you launch .vgm files.

Program link: https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/opl3snooper.pgz
|-
|opl3tweak
|uses MIDI in, plays 18 channels polyphony in real time to the YMF262 OPL3. Fish for random register values.
|Mu0n
|pgz
|v0.1. Can't save or load instrument definitions yet. Needs a K2 with a MIDI in currently. https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/opl3tweak.pgz
Arrows to move around, + and - keys to incr/decr values or type in a hex value directly under the highlighted position.
|-
|piano
|Plays some PSG notes with the keyboard
|Mu0n
|basic
|https://github.com/Mu0n/F256KbasicBASICdoodles?tab=readme-ov-file#pulse-sound-generator-piano
|-
|playvgm
|plays a headless vgm file with OPL3
|G33kyAndIKnowIt
|pgx
|https://github.com/natebarney/playvgm-f256k
some example music files can be gotten from this post:
[https://discord.com/channels/691915291721990194/975117322836656138/1220366429640065074 https://discord.com/channels/6][https://discord.com/channels/691915291721990194/975117322836656138/1220366429640065074 91915291721990194/975117322836656138/1220366429640065074]

1) open a normal .vgm into a hex editor <nowiki/>and cut out the header bytes from 0x00 to 0x<nowiki/>FF

2) run by first using superbasic's '''''bload''''' '''''"yourmusicfile", $01000'''''
followed by running this program with '''''/- playvgm.pgx'''''
|-
|sidtweak
|uses MIDI in, plays 6 channels polyphony in real time to the dual SID. Fish for random register values.
|Mu0n
|pgz
|v0.1. Can't save or load instrument definitions yet. Needs a K2 with a MIDI in currently. https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/sidtweak.pgz
Arrows to move around, + and - keys to incr/decr values or type in a hex value directly under the highlighted position.
|-
|rawsidplayer
|plays raw PSID files from the HVSC collection, converted by zigreSID
|Mu0n
|pgz
|(formely psidplayer) v0.2 find rawsidplayer.pgz and a starter .rsd file (raw sid dumps). For a starter collection of .rsd files, check the SD curated collection here: https://github.com/Mu0n/F256MiscGoodies/tree/main/SDCard_Collection
extract sid.zip into a folder /sid/ in the root of your SD card, that's where psidplayer.pgz will first look to let you pick a file. failing that, it will fall back to the root folder and let you navigate.

program link:

https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/rawsidplayer.pgz
|-
|tracker2 v1.5
|Like jrtracker.bas, but using both PSGs
|contrerasd
|basic
|https://github.com/econtrerasd/Tracker2/releases
|}

== Uti<nowiki/>lities ==

{| class="wikitable"
|+
!Program
!Descrip<nowiki/>tion
!Author
!Notes on running
!Link
|-
|basic2text
|A simple utility for translating Commodore BASIC (all variants) from its native tokenized file format to a text format that can be opened with SuperBASIC. Does not perform any code translation: all adaptation is up to you.
|Micah
|pgZ
|https://github.com/WartyMN/F256-BasText/releases/latest
|
|-
|dcopy
|A tool to copy files from one drive to another or to/from your PC via RS-232 and a nullmodem cable
|mgr42
|pgz/flash
|https://github.com/rmsk2/f256_dcopy
|
|-
|f/manager
|A general file utility, launcher, and memory viewing program. Dual-panel file/memory browsers; copy between disks, between folders on same disk, and from memory to disk and vice versa; delete, rename, and duplicate files; view files as hex or text (with word-wrap); launch applications and known file types; set the RTC clock; search in RAM and flash. Works with internal SD card and IEC devices such as FNX1591 and Commodore 1541. Can be installed in primary flash position ahead of SuperBASIC or DOS, or at a higher location. Can also be run from disk with "- fm.pgz".
|Micah
|pgZ/flash
|https://github.com/WartyMN/F256-FileManager/releases
|
|-
|f256_reset
|A small utility that lets you reset the machine through this piece of flash software
|mgr42
|flash
|https://github.com/rmsk2/f256_reset
|
|-
|fcart
|A program that allows to write data to flash expansion cartridges
|mgr42
|pgz, on-board and cartridge flash
|https://github.com/rmsk2/cartflash
|
|-
|flashcart
|Allows to wipe a block of flash or write a program to a flash cart, from this basic program from the F256Jr/K
|redfool.
|basic
|https://github.com/Red-Fool/F256_FlashCart/tree/main
|
|-
|flashselect
|Allows to select a program to start from a flash cartridge via a menu
|mgr42
|pgz, on-board and cartridge flash
|https://github.com/rmsk2/flashselect
|
|-
|fonts
|A variety of fonts using the standard F256 character set arrangement. Load with the F256 file manager (f/manager), or your own code.
|Micah
|(not a program)
|[https://github.com/WartyMN/Foenix-Fonts/tree/main https://github.com/WartyMN/Foenix-Fonts]
|
|-
|midiStuff
|Test program for a F256K2 or F256Jr2 that sends MIDI data to the internal sam2695 dream chip that produces MIDI based audio. Also test a keyboard controller plugged in the MIDI in port.
|Mu0n
|pgz
|https://github.com/Mu0n/F256KsimpleCdoodles/blob/main/README.md#midistuff
|
|-
|moreorless
|A text editor for the Foenix 256 line of computers
|mgr42
|pgz
|https://github.com/rmsk2/moreorless/releases/
|
|-
|pgz2flash
|A program for your Linux, Windows or MacOS machine to turn any PGZ or SuperBASIC program into a KUP which can be run from cartridge or onboard flash memory
|mgr42
|Executable for modern computers
|https://github.com/rmsk2/pgz2flash
|
|-
|sidTester
|Simple superbasic program that tests out all 3 voices of the SID1 on the Jr (if populated), K, Jr2 and K2. Ported by Mu0n, made by andy on HackJunk.com https://hackjunk.com/2017/11/07/commodore-64-sid-tester/
|andy
|basic
|https://github.com/Mu0n/F256MiscGoodies/blob/main/apps/sidtester.bas
|
|-
|testsuite.bas
|a series of tests for your F256, video modes and sound chips
|econtrerasd
|basic
|run from the root,
https://github.com/econtrerasd/testSuite-F256/releases
|
|-
|wget<nowiki/>
|<nowiki/>fetches a file from a http address if you have a network connection active. Works with the K and Jr. ESP32 Feather 'huzzah' board. Not meant to be used with the K2 and Jr2 Wiznet chip.
|gadget
|<nowiki/>pgz/flash
|https://github.com/ghackwrench/F256_wget
|
|}

== Sample Code ==

{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|Assembly examples
|Sample programs for several features of the Foenix F256K and Jr.
|mgr42
|read github
|https://github.com/rmsk2/Hello_Foenix256_Jr/blob/main/testprogs.md
|-
|cc65 example
|c example code
|gadget
|read github
|https://github.com/ghackwrench/F256_Jr_Kernel_DOS
|-
|digarok basic stuff
|Lots of basic examples
|digarok
|read github
|https://github.com/digarok/superbasic-traveler/tree/main
|-
|Mu0n's F256K asm doodles
|Some asm examples
|Mu0n
|read github
|https://github.com/Mu0n/F256KsimpleASMdoodles
|-
|Mu0n's F256K basic doodles
|Some basic examples
|Mu0n
|read github
|https://github.com/Mu0n/F256KbasicBASICdoodles
|-
|Mu0n's F256K C doodles
|Some C examples
|Mu0n
|read github
|https://github.com/Mu0n/F256KsimpleCdoodles
|-
|Raúl SQ basic repo
|F256 SuperBASIC Trigonometry
|Raúl SQ
|basic
|https://github.com/raul-sq/FoenixF256K2
|-
|tcp example
|connects to a server and gets typed in text echoed back to you
|gadget
|$2000
|https://github.com/ghackwrench/F256_example_tcp
|}

Software for 6502

2026-01-07T18:07:46Z

1BitFeverDreams: /* Music */ v1.1 for opl3snooper in desc

Note that when an hex address is given, it's meant to instruct as to which address to bload or to send (ie foenixmgr python script) the program (ie a .bin file) to before running it. For extra help on how to run .bin files and almost every possible scheme that has to be used to run program, you can consult this video that's also part of [[Getting Started]], this one: https://www.youtube.com/watch?v=0ShFv89KGDs

Many download links are posts in the main [https://discord.gg/9vjUEGgcUS Foenix Retro Systems discord server] which will require you to join in order to get to them.

A [[Getting Started#Demos Archive|Demo Archive]] was put together in September 2023 to get ready to show to youtubers, some of these are linked once more, in this page.

There's also the Foenix Marketplace website maintained by EMWhite with its own collection of articles and software http://apps.emwhite.org/foenixmarketplace/.

===== Curated SD card collection of games, demos, utilities =====
Here is a download link to a zip file meant to be extracted into the root of an SD card: https://github.com/Mu0n/F256MiscGoodies/tree/main/SDCard_Collection

Best to wipe out your SD card and start anew with the contents of this extracted to root. Micah's file manager doesn't like long lists of files so it really is best to not overdo it. I tried to minimize the files in root, but I couldn't for everything.

Open the readme.txt file with moreorless to see some instructions about the collection. Best to run /- fm first, then open the readme.txt from it

== Applications ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|F256 f/term
|Terminal emulator for F256K and Jr with classic (flat) memory load
|Micah
| - fterm.pgZ or use f/manager
|https://github.com/WartyMN/F256-terminal/blob/main/release/fterm.pgZ
|-
|FoenixTarot
|Tarot card readings in SuperBasic
|Mike
|basic
|https://github.com/mcassera/FoenixTarot/tree/main
|-
|Forthf256
|Forth implementation
|Vasyl
|pgz in its forth/ folder
|https://github.com/VasylTsv/ForthX16
|-
|WildBits Graphic Toolkit
|(fmr. F256-GraphicToolkit) Sprite editor, Tilemap editor, Font editor + misc tools
|econtrerasd
|basic
|https://github.com/econtrerasd/F256-GraphicToolkit/releases
|}

== Demos ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|badapple
|A 80x60 textmode port of Bad Apple, uses the VS1053b for quality mp3 audio. Needs a Jr2 or K2!
|Mu0n
|pgz*
|*unzip badapple.zip into the root of your SD card. If done right, the 3 files within will be in the demos/ folder. The program expects its data file there when it runs. https://github.com/Mu0n/F256MiscGoodies/blob/main/apps/badapple.zip
|-
|balls
|Draw a good quantity of multiplexed sprites, fast. Balls bouncing around
|celton
|pgz
|https://github.com/FoenixRetro/demos/blob/main/MultiplexedSprites.md
|-
|F256Archon
|Splash screen intro, plays MIDI using the SAM2695, requires a K2 or Jr2
|Mu0n
|pgz
|https://github.com/Mu0n/F256Archon/releases
|-
|f256_life
|An implementation of Conway's game of life
|mgr42
|pgz
|https://github.com/rmsk2/f256_life
|-
|F256 Mandelbrot
|Draws Mandelbrot set fast (5 mins) using coprocessor math. Allows to zoom into the set.
|mgr42
|uses basic loader
|https://github.com/rmsk2/F256_Mandelbrot
|-
|F256ShowCase
|Shows sliding tiling graphics, moves with joystick
|eriktier
|$0000
|https://github.com/pig-games/F256Showcase
|-
|fnxmas23
|PSG mod music, scrolling text, sound effects, must see demo!
|dwsJason and digarok
|pgz
|https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/apps/xmas24_k2.pgz revised version that can run on wave 2 Jr2 and K2 as well
|-
|foenixmas23
|Xmas 2023 demo with SID music from the classic 1983 C64 xmas demo
|EMWhite
|uses basic loader
|http://apps.emwhite.org/shared-files/815/?foenixmas23.zip
|-
|livingworlds
|Living Worlds, a port of a color cycling by Mark Ferrari, ported here on the F256 by haydenkale
|haydenkale
|$0000
|https://github.com/clandrew/livingworlds/tree/e4532e0d530b76ccb90368fdf5ad10bfa2deeb12
|-
|mandel
|Will draw a mandelbrot set in 3 hours, more useful as a stability test than a useful fractal program
|Mu0n
|basic
|https://github.com/Mu0n/F256KbasicBASICdoodles?tab=readme-ov-file#fractal
|-
|mariobros
|Tilemap and platformer test based on Mario Bros. (1983)
|beethead
|pgz
|https://github.com/noyen1973/mariobros
|-
|wormhole
|Shows a fast wireframe animation of a wormhole
|haydenkale
|pgz or bin at $0000
|https://github.com/clandrew/wormhole?tab=readme-ov-file
|}

== Games ==

{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|bbombers
|Boulder Bombers (Alpha-2) Clone of Canyon Bombers
|Scott (xDraconian)
|pgx
atari joystick
|https://github.com/scttgs0/BoulderBombers<nowiki/>https://github.com/scttgs0/BoulderBombers/releases/tag/alpha_2
|-
|Bombsweeper
|Bomb sweeper port
|beethead
|pgz
|https://discord.com/channels/691915291721990194/855689509520932885/1196352934083035156
|-
|Cosmic
|Shoot 'em up
|beethead
|pgz
|https://discordapp.com/channels/691915291721990194/1054250238308790342/1175982979537969214
|-
|F256-Trek
|Updated Trek, with modern F256 Graphics
|econtrerasd
|basic
|[https://github.com/econtrerasd/Trek-F256/releases/tag/v1.0 https://github.com/econtrerasd/Trek-F256/releases]
|-
|F256 two to the power of eleven
|Port of the puzzle game of 2048
|mgr42
|pgz
|https://github.com/rmsk2/F256_2048<nowiki/>
|-
|fillerup
|Fill 'er Up (WIP)
Qix-like game
|Scott (xDraconian)
|pgx
atari joystick
|https://github.com/scttgs0/Fill-er-up
|-
|FusionDrive
|An outrun type game that also plays a MIDI soundtrack
|Mu0n
|pgz
|wip v0.2, can use a NES pad #1 to move around, or left/right arrow keys currently https://github.com/Mu0n/F256KsimpleCdoodles/tree/main/NoFussDemos
|-
|jewelkeeper
|Sokoban port
|beethead
|pgz
|https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/apps/jewelkeeper.pgz<nowiki/>You can now specify a level file when loading the game <code>/- jewelkeeper.pgz <levels.txt></code>. Find more levels at https://www.sourcecode.se/sokoban/levels.php. Keep in mind the maximum level dimension is 20x15, anything larger will be ignored
|-
|Jr Wördl
|port of Wordle
|AgeAgeEye
|basic
|https://github.com/ageageeye/Superbasic-F256Jr-examples
|-
|kartdemo
|Kart racing game
|SprySloth
|pgz
|https://discord.com/channels/691915291721990194/1225217654487253094/1228246780840513556
|-
|Lair of the Lich King
|Rogue like dungeon crawler. Demo has 3 levels; full has 25+
|Micah
| - lkdemo/lk.pgz
|[https://discord.com/channels/691915291721990194/1230670413361844244/1317256215566487593 1.0 Beta 19 Demo]
|-
|livewire
|Livewire (WIP)
Tempest-like game
|Scott (xDraconian)
|pgx
atari joystick
|https://github.com/scttgs0/Livewire
|-
|Maze-Munch
|Pac-Man clone
|SprySloth
|pgz
|https://github.com/cmassat/Maze-Munch
|-
|pdefense
|Planetary Defense (WIP)
|Scott (xDraconian)
|pgx
mouse
atari joystick
|https://github.com/scttgs0/PlanetaryDefense
|-
|Shanghai/Mahjongg
|A clone of Shanghai. Also known as Mahjongg
|mgr42
|pgz or KUP
mouse needed
|https://github.com/rmsk2/f256_mahjong
|-
|Ski-Jr
|Ski game downhill
|digarok
|basic
|https://github.com/digarok/superbasic-traveler/blob/main/ski-jr.bas
|-
|Track & Field
|Olympic Game by Konami (WIP)
|Scott (xDraconian)
|pgz
atari joystick or keyboard
|
|-
|Tetris
|Good old 80's game
|Daniel Tremblay (Grenouye)
|pgz
atari joystick or keyboard
|https://github.com/dtremblay/c256-tetris/tree/f256k
|}

== Game Jam #01 - April 6th/7th 2024 ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|15puzzle
|Number sort puzzle
|mgr42
|pgz
|https://github.com/rmsk2/f256_15puzzle/releases<nowiki/>
|-
|Flight Simulator
|flying simulator
|sduensin
|pgz
|https://cdn.discordapp.com/attachments/1225481966200029286/1227764847819620454/shotel.pgz
|-
|frisbee
|Frisbee throw past sport game
|dwsJason
|pgz
|https://github.com/dwsJason/f256/blob/develop/merlin32/frisbee/frisbee.pgz
|-
|Impasse
|Shoot 'em up
|digarok
|pgz
|https://discord.com/channels/691915291721990194/1225481966200029286/1227075699895046235
|-
|soccur
|mutliplayer game of soccer
|beethead
|pgz
|executable:https://discord.com/channels/691915291721990194/1225481966200029286/1226808228948611184
source code:
https://discord.com/channels/691915291721990194/1225481966200029286/1226812472069980232
|-
|Trek
|port of classic Star Trek game
|contrerasd
|basic
|https://discord.com/channels/691915291721990194/1225481966200029286/1226727849944289341
|-
|Typing Star
|typing reaction game
|haydenkale
|pgz
|https://github.com/clandrew/typestar
|-
|}

== Game Jam #02 - October 25th-November 1st 2024 ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|Bach's MIDI Hero
|Free MIDI/PSG play + note play tutorial
|Mu0n
|pgz
the MIDI feature requires a F256K2 or F256Jr2; a legacy PSG option also allows F256K and F256Jr to still hear it. Optionally uses a MIDI in controller plugged in.
|https://github.com/Mu0n/F256KsimpleCdoodles/releases/download/v1.2/BachHero.pgz
|-
|f256_snake
|
|mgr42
|pgz. Use cursor keys, Atari joystick or SNES pad to play
|https://github.com/rmsk2/f256_snake
|-
|fnxsnake
|
|silk-neon
|pgz
|https://github.com/ksiondag/fnxsnake
|-
|The Hallow
|
|beethead
|pgz
|https://github.com/noyen1973/FoenixGameJamOct2024
|-
|Halloween Birthday
|
|SprySloth
|pgz
|https://github.com/cmassat/GameJam2024_F256K
|-
|Haunted Mansion
|
|digarok
|superbasic
|https://github.com/digarok/fnxgamejam-haunted-mansion
|-
|Kooyan
|
|Grenouye
|pgz
|https://github.com/dtremblay/kooyan.git
|-
|Spooky Run
|
|dwsJason
|pgz
|https://github.com/dwsJason/spooky
|-
|Trick or Treat
|
|Mike
|pgz
|https://github.com/mcassera/TrickOrTreat
|-
|Ultima III - Exodus
|port
|Minstrel Dragon
|pgz
|https://github.com/minstreldragon/F256_Ultima_3
|-
|Warlock
|remake of 68000 game
|xDraconian
|pgz
atari joystick
DOWN=change_level
UP=jump
UP-LEFT=leap
UP-RIGHT=leap
|https://github.com/scttgs0/Foenix_GameJam_Oct2024
|}

== Game Jam #03 - April 18th-April 27th 2025 ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|Arcade Shanghai v1.2
|Shanghai clone
|contrerasd
|basic, keep the .bas program in root, the rest in the provided ashanghai/ folder
|https://github.com/econtrerasd/ashanghai/releases
|-
|Bawk Bawk Cluck Cluck
|Chicken themed platformer
|beethead
|pgz
|https://github.com/noyen1973/FoenixGameJamApr2025
|-
|BitLadder
|Shoot 'Em Up
|Mu0n
|pgz. For full sound compatibility, a Jr2 or K2 is needed.
Uses 4 sound chips! (PSG, SID, OPL3, MIDI)
|https://mu0n.itch.io/bitladder
|-
|F256_Commando
|Commando port
|SprySloth
|pgz
|https://github.com/cmassat/F256_Commando
|-
|F256_LodeRunner
|Lode Runner port
|Minstrel Dragon
|pgz
|https://github.com/minstreldragon/F256_Loderunner/releases
|-
|Mahjong
|Shangai clone
|mgr42
|pgz
|https://github.com/rmsk2/f256_mahjong/releases
|-
|Quarth
|Block placement arcade game
|Grenouye
|pgz
|https://grenouye.itch.io/f256-quarth
|-
|Skee(ster)-Ball
|
|Mike
|pgz
|https://github.com/mcassera/skeeball256/tree/main
|}

== Game Jam #04 - November-December 2025 ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|Fallitaire
|A cozy fall-themed twist on Pyramid Solitaire, built for the Foenix F256K2 Game Jam!
|Programmer Vs World
|bas
|https://programmervsworld.itch.io/fallitaire
|-
|H.E.R.O.
|Port of the classic game H.E.R.O.
|Cibee
|pgz
|https://c1bee.itch.io/hero
|-
|Leaderboard
|Golf game
|xDraconian
|pgz
|https://discord.com/channels/691915291721990194/1424187774642290799/1456104940186501132
|-
|Pitfall
|Port of the classic Pitfall game from Activision
|MinstrelDragon
|pgz
|https://minstrel.itch.io/pitfall-foenix-f256x
|-
|Return of the Falcon
|
|Callisto
|TBD
|
|-
|Swicheroo
|An Alternate Puzzle Game
|jbaker8935
|pgz
|https://jbaker8935.itch.io/switcheroo
|-
|Track Day
|v1.0 top down race game vs computer controlled opponents
|MikeC
|pgz
|https://mcassera.itch.io/track-day-racing
|}

== Music ==

{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|cozyMIDI
|Plays a SMF with the SAM2695 or VS1053b
|Mu0n
|pgz
|cozyMIDI v2.4 can open and play type 0 and type 1 standard MIDI files (SMF)
needs a Jr2 or K2
with a 2x core at https://github.com/Mu0n/F256KsimpleCdoodles/tree/main/NoFussDemos

run operation 1: just as itself, it will force you to pick a midi file in the 'midi/' folder /- cozymidi

run operation 2: in f/manager, if you put this as <code>midiplayer.pgz</code>in the '_apps/' folder, f/manager will open midi file with it when you launch .mid files.

Program link: https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/cozymidi.pgz
|-
|digestMidi
|converts .mid to .dim
|Mu0n
|pgz
|.mid files are slow to load, parse and prepare for a playback. This tool comes in to convert them into a .dim format that strips out unnecessary MIDI commands and sets it up for timer0 time delays. Works with type 0 and type 1 standard midi files. This tools does the conversion and lets you hear the result.
Find the latest version here: https://github.com/Mu0n/F256MiscGoodies/tree/main/apps
|-
|EdInHisLib
|SID+OPL3 simultaneously
|beethead, ported from xantax
|pgz
|F256 port: https://discordapp.com/channels/691915291721990194/1054249926521016392/1184413356598231120
original: <nowiki>https://csdb.dk/release/?id=170898</nowiki>. Not 100% accurate but close.
|-
|F256amp
|mp3, ogg, wav, wma file playback
|Mu0n
|pgz
|(aka audioplayer.pgz) v2.3 Needs a Jr.2 or K2 since it uses the VS1053b chip.
For a starter collection of .mp3 and other audio files, check the SD curated collection here: https://github.com/Mu0n/F256MiscGoodies/tree/main/SDCard_Collection
run operation 1: just as itself, it will force you to pick an audio file. it expects a <code>media/mp3/</code> folder, but it can live without it and peek into the root instead.

run operation 2: with an argument, it will auto-play it: /- f256amp yourmp3file.mp3

run operation 3: in f/manager, if you put this as <code>audioplayer.pgz</code> in the '_apps/' folder. This lets f/manager automatically open up .mp3, .wav, .ogg, .wma that you press enter on.

Program link: https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/f256amp.pgz
|-
|FireJam
|all chips, music playing with MIDI in
|Mu0n
|pgz
|v1.2 MIDI in and out capable, it will still partially work with a Jr. (PSG, and SID if you have them), a K (PSG, SID, OPL3) and the newest wave 2 Jr2 and K2 (PSG, SID, OPL3, SAM, VS1053b).
Best to use with a MIDI in controller, but it'll be controllable with arrows and space to make notes individually, or the F keys to start beats. https://github.com/Mu0n/F256KsimpleCdoodles/tree/main/NoFussDemos
|-
|jrtracker
|Tracker based in basic and uses the PSG
(considered obsolete, use tracker2)
|contrerasd
|basic
|https://ptb.discord.com/channels/691915291721990194/1008139105386889346/1188292876984143983
|-
|modo
|MOD player using the PSG
|dwsJason and digarok
|pgz
|https://discordapp.com/channels/691915291721990194/855689509520932885/1190723114661859429
|-
|Musik
|Music piece demo using MIDI
|Mike
|pgz
|https://github.com/mcassera/Musik/blob/main/Musik.PGZ<nowiki/>Musikalisches Würfelspiel
Requires a Jr2 or K2 since it uses MIDI
|-
|opl3snooper
|playback of VGM files (that use opl2 and opl3) and MIDI in
|Mu0n
|pgz
|v1.1 mainly plays back vgm files, but you can pause it and snoop around the channel instruments and play up to 18 note polyphony with MIDI in. expects a collection in media/vgm/, or it will browse from the root if it can't find.
It can load a .spl (Simple PLaylist) text file, which is one file per line, including their respective paths.
Requires a Jr2 or K2 with a 2x core to use the extra bank of SRAM.
For a starter collection of .vgm files, check the SD curated collection here: https://github.com/Mu0n/F256MiscGoodies/tree/main/SDCard_Collection
run operation 1: just as itself, it will force you to pick a midi file in the 'media/vgm/' folder

run operation 2: in f/manager (v1.1b9 and up), if you put this as <code>vgmplayer.pgz</code>in the '_apps/' folder, f/manager will open midi file with it when you launch .vgm files.

Program link: https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/opl3snooper.pgz
|-
|opl3tweak
|uses MIDI in, plays 18 channels polyphony in real time to the YMF262 OPL3. Fish for random register values.
|Mu0n
|pgz
|v0.1. Can't save or load instrument definitions yet. Needs a K2 with a MIDI in currently. https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/opl3tweak.pgz
Arrows to move around, + and - keys to incr/decr values or type in a hex value directly under the highlighted position.
|-
|piano
|Plays some PSG notes with the keyboard
|Mu0n
|basic
|https://github.com/Mu0n/F256KbasicBASICdoodles?tab=readme-ov-file#pulse-sound-generator-piano
|-
|playvgm
|plays a headless vgm file with OPL3
|G33kyAndIKnowIt
|pgx
|https://github.com/natebarney/playvgm-f256k
some example music files can be gotten from this post:
[https://discord.com/channels/691915291721990194/975117322836656138/1220366429640065074 https://discord.com/channels/6][https://discord.com/channels/691915291721990194/975117322836656138/1220366429640065074 91915291721990194/975117322836656138/1220366429640065074]

1) open a normal .vgm into a hex editor <nowiki/>and cut out the header bytes from 0x00 to 0x<nowiki/>FF

2) run by first using superbasic's '''''bload''''' '''''"yourmusicfile", $01000'''''
followed by running this program with '''''/- playvgm.pgx'''''
|-
|sidtweak
|uses MIDI in, plays 6 channels polyphony in real time to the dual SID. Fish for random register values.
|Mu0n
|pgz
|v0.1. Can't save or load instrument definitions yet. Needs a K2 with a MIDI in currently. https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/sidtweak.pgz
Arrows to move around, + and - keys to incr/decr values or type in a hex value directly under the highlighted position.
|-
|rawsidplayer
|plays raw PSID files from the HVSC collection, converted by zigreSID
|Mu0n
|pgz
|(formely psidplayer) v0.2 find rawsidplayer.pgz and a starter .rsd file (raw sid dumps). For a starter collection of .rsd files, check the SD curated collection here: https://github.com/Mu0n/F256MiscGoodies/tree/main/SDCard_Collection
extract sid.zip into a folder /sid/ in the root of your SD card, that's where psidplayer.pgz will first look to let you pick a file. failing that, it will fall back to the root folder and let you navigate.

program link:

https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/rawsidplayer.pgz
|-
|tracker2 v1.5
|Like jrtracker.bas, but using both PSGs
|contrerasd
|basic
|https://github.com/econtrerasd/Tracker2/releases
|}

== Uti<nowiki/>lities ==

{| class="wikitable"
|+
!Program
!Descrip<nowiki/>tion
!Author
!Notes on running
!Link
|-
|basic2text
|A simple utility for translating Commodore BASIC (all variants) from its native tokenized file format to a text format that can be opened with SuperBASIC. Does not perform any code translation: all adaptation is up to you.
|Micah
|pgZ
|https://github.com/WartyMN/F256-BasText/releases/latest
|
|-
|dcopy
|A tool to copy files from one drive to another or to/from your PC via RS-232 and a nullmodem cable
|mgr42
|pgz/flash
|https://github.com/rmsk2/f256_dcopy
|
|-
|f/manager
|A general file utility, launcher, and memory viewing program. Dual-panel file/memory browsers; copy between disks, between folders on same disk, and from memory to disk and vice versa; delete, rename, and duplicate files; view files as hex or text (with word-wrap); launch applications and known file types; set the RTC clock; search in RAM and flash. Works with internal SD card and IEC devices such as FNX1591 and Commodore 1541. Can be installed in primary flash position ahead of SuperBASIC or DOS, or at a higher location. Can also be run from disk with "- fm.pgz".
|Micah
|pgZ/flash
|https://github.com/WartyMN/F256-FileManager/releases
|
|-
|f256_reset
|A small utility that lets you reset the machine through this piece of flash software
|mgr42
|flash
|https://github.com/rmsk2/f256_reset
|
|-
|fcart
|A program that allows to write data to flash expansion cartridges
|mgr42
|pgz, on-board and cartridge flash
|https://github.com/rmsk2/cartflash
|
|-
|flashcart
|Allows to wipe a block of flash or write a program to a flash cart, from this basic program from the F256Jr/K
|redfool.
|basic
|https://github.com/Red-Fool/F256_FlashCart/tree/main
|
|-
|flashselect
|Allows to select a program to start from a flash cartridge via a menu
|mgr42
|pgz, on-board and cartridge flash
|https://github.com/rmsk2/flashselect
|
|-
|fonts
|A variety of fonts using the standard F256 character set arrangement. Load with the F256 file manager (f/manager), or your own code.
|Micah
|(not a program)
|[https://github.com/WartyMN/Foenix-Fonts/tree/main https://github.com/WartyMN/Foenix-Fonts]
|
|-
|midiStuff
|Test program for a F256K2 or F256Jr2 that sends MIDI data to the internal sam2695 dream chip that produces MIDI based audio. Also test a keyboard controller plugged in the MIDI in port.
|Mu0n
|pgz
|https://github.com/Mu0n/F256KsimpleCdoodles/blob/main/README.md#midistuff
|
|-
|moreorless
|A text editor for the Foenix 256 line of computers
|mgr42
|pgz
|https://github.com/rmsk2/moreorless/releases/
|
|-
|pgz2flash
|A program for your Linux, Windows or MacOS machine to turn any PGZ or SuperBASIC program into a KUP which can be run from cartridge or onboard flash memory
|mgr42
|Executable for modern computers
|https://github.com/rmsk2/pgz2flash
|
|-
|sidTester
|Simple superbasic program that tests out all 3 voices of the SID1 on the Jr (if populated), K, Jr2 and K2. Ported by Mu0n, made by andy on HackJunk.com https://hackjunk.com/2017/11/07/commodore-64-sid-tester/
|andy
|basic
|https://github.com/Mu0n/F256MiscGoodies/blob/main/apps/sidtester.bas
|
|-
|testsuite.bas
|a series of tests for your F256, video modes and sound chips
|econtrerasd
|basic
|run from the root,
https://github.com/econtrerasd/testSuite-F256/releases
|
|-
|wget<nowiki/>
|<nowiki/>fetches a file from a http address if you have a network connection active. Works with the K and Jr. ESP32 Feather 'huzzah' board. Not meant to be used with the K2 and Jr2 Wiznet chip.
|gadget
|<nowiki/>pgz/flash
|https://github.com/ghackwrench/F256_wget
|
|}

== Sample Code ==

{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|Assembly examples
|Sample programs for several features of the Foenix F256K and Jr.
|mgr42
|read github
|https://github.com/rmsk2/Hello_Foenix256_Jr/blob/main/testprogs.md
|-
|cc65 example
|c example code
|gadget
|read github
|https://github.com/ghackwrench/F256_Jr_Kernel_DOS
|-
|digarok basic stuff
|Lots of basic examples
|digarok
|read github
|https://github.com/digarok/superbasic-traveler/tree/main
|-
|Mu0n's F256K asm doodles
|Some asm examples
|Mu0n
|read github
|https://github.com/Mu0n/F256KsimpleASMdoodles
|-
|Mu0n's F256K basic doodles
|Some basic examples
|Mu0n
|read github
|https://github.com/Mu0n/F256KbasicBASICdoodles
|-
|Mu0n's F256K C doodles
|Some C examples
|Mu0n
|read github
|https://github.com/Mu0n/F256KsimpleCdoodles
|-
|Raúl SQ basic repo
|F256 SuperBASIC Trigonometry
|Raúl SQ
|basic
|https://github.com/raul-sq/FoenixF256K2
|-
|tcp example
|connects to a server and gets typed in text echoed back to you
|gadget
|$2000
|https://github.com/ghackwrench/F256_example_tcp
|}

Software for 65816

2026-01-06T05:10:10Z

1BitFeverDreams: /* Demos */ better link to the spr128b demo

Note that when an hex address is given, it's meant to instruct as to which address to bload or to send (ie foenixmgr python script) the program (ie a .bin file) to before running it.

Many download links are posts in the main [https://discord.gg/9vjUEGgcUS Foenix Retro Systems discord server] which will require you to join in order to get to them.

===== Curated SD card collection of games, demos, utilities =====
Will be provided when one is prepared

===== Why is this empty? =====
There's not a lot of 16-bit applications done and people aren't pro-active at sharing github download links! PLEASE HELP!

== Applications ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|
|
|
|
|
|}

== Demos ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|hwline2.bas
|Displays hardware accelerated lines (classic screen saver)
|Econtrerasd
|basic, needs 2x core
|https://github.com/Mu0n/F256MiscGoodies/blob/main/apps/hwline2.bas
|-
|newlines.pgz
|Toggles between new hardware accelerated lines and old drawn lines
|Mu0n
|pgz, needs 2x core
|https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/newlines.pgz
|-
|spr128b.pgz
|Displays all 128 sprites
|beethead
|pgz, needs 2x core
|https://github.com/noyen1973/spr128-F256K2
|}

== Games ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|
|
|
|
|
|}

== Music ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|
|
|
|
|
|}

== Utilities ==
== Sample Code ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|
|
|
|
|
|}

Software for 6502

2026-01-03T21:49:12Z

1BitFeverDreams: new game jam (4 entries) and demos/mariobros from beethead

Note that when an hex address is given, it's meant to instruct as to which address to bload or to send (ie foenixmgr python script) the program (ie a .bin file) to before running it. For extra help on how to run .bin files and almost every possible scheme that has to be used to run program, you can consult this video that's also part of [[Getting Started]], this one: https://www.youtube.com/watch?v=0ShFv89KGDs

Many download links are posts in the main [https://discord.gg/9vjUEGgcUS Foenix Retro Systems discord server] which will require you to join in order to get to them.

A [[Getting Started#Demos Archive|Demo Archive]] was put together in September 2023 to get ready to show to youtubers, some of these are linked once more, in this page.

There's also the Foenix Marketplace website maintained by EMWhite with its own collection of articles and software http://apps.emwhite.org/foenixmarketplace/.

===== Curated SD card collection of games, demos, utilities =====
Here is a download link to a zip file meant to be extracted into the root of an SD card: https://github.com/Mu0n/F256MiscGoodies/tree/main/SDCard_Collection

Best to wipe out your SD card and start anew with the contents of this extracted to root. Micah's file manager doesn't like long lists of files so it really is best to not overdo it. I tried to minimize the files in root, but I couldn't for everything.

Open the readme.txt file with moreorless to see some instructions about the collection. Best to run /- fm first, then open the readme.txt from it

== Applications ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|F256 f/term
|Terminal emulator for F256K and Jr with classic (flat) memory load
|Micah
| - fterm.pgZ or use f/manager
|https://github.com/WartyMN/F256-terminal/blob/main/release/fterm.pgZ
|-
|FoenixTarot
|Tarot card readings in SuperBasic
|Mike
|basic
|https://github.com/mcassera/FoenixTarot/tree/main
|-
|Forthf256
|Forth implementation
|Vasyl
|pgz in its forth/ folder
|https://github.com/VasylTsv/ForthX16
|-
|WildBits Graphic Toolkit
|(fmr. F256-GraphicToolkit) Sprite editor, Tilemap editor, Font editor + misc tools
|econtrerasd
|basic
|https://github.com/econtrerasd/F256-GraphicToolkit/releases
|}

== Demos ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|badapple
|A 80x60 textmode port of Bad Apple, uses the VS1053b for quality mp3 audio. Needs a Jr2 or K2!
|Mu0n
|pgz*
|*unzip badapple.zip into the root of your SD card. If done right, the 3 files within will be in the demos/ folder. The program expects its data file there when it runs. https://github.com/Mu0n/F256MiscGoodies/blob/main/apps/badapple.zip
|-
|balls
|Draw a good quantity of multiplexed sprites, fast. Balls bouncing around
|celton
|pgz
|https://github.com/FoenixRetro/demos/blob/main/MultiplexedSprites.md
|-
|F256Archon
|Splash screen intro, plays MIDI using the SAM2695, requires a K2 or Jr2
|Mu0n
|pgz
|https://github.com/Mu0n/F256Archon/releases
|-
|f256_life
|An implementation of Conway's game of life
|mgr42
|pgz
|https://github.com/rmsk2/f256_life
|-
|F256 Mandelbrot
|Draws Mandelbrot set fast (5 mins) using coprocessor math. Allows to zoom into the set.
|mgr42
|uses basic loader
|https://github.com/rmsk2/F256_Mandelbrot
|-
|F256ShowCase
|Shows sliding tiling graphics, moves with joystick
|eriktier
|$0000
|https://github.com/pig-games/F256Showcase
|-
|fnxmas23
|PSG mod music, scrolling text, sound effects, must see demo!
|dwsJason and digarok
|pgz
|https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/apps/xmas24_k2.pgz revised version that can run on wave 2 Jr2 and K2 as well
|-
|foenixmas23
|Xmas 2023 demo with SID music from the classic 1983 C64 xmas demo
|EMWhite
|uses basic loader
|http://apps.emwhite.org/shared-files/815/?foenixmas23.zip
|-
|livingworlds
|Living Worlds, a port of a color cycling by Mark Ferrari, ported here on the F256 by haydenkale
|haydenkale
|$0000
|https://github.com/clandrew/livingworlds/tree/e4532e0d530b76ccb90368fdf5ad10bfa2deeb12
|-
|mandel
|Will draw a mandelbrot set in 3 hours, more useful as a stability test than a useful fractal program
|Mu0n
|basic
|https://github.com/Mu0n/F256KbasicBASICdoodles?tab=readme-ov-file#fractal
|-
|mariobros
|Tilemap and platformer test based on Mario Bros. (1983)
|beethead
|pgz
|https://github.com/noyen1973/mariobros
|-
|wormhole
|Shows a fast wireframe animation of a wormhole
|haydenkale
|pgz or bin at $0000
|https://github.com/clandrew/wormhole?tab=readme-ov-file
|}

== Games ==

{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|bbombers
|Boulder Bombers (Alpha-2) Clone of Canyon Bombers
|Scott (xDraconian)
|pgx
atari joystick
|https://github.com/scttgs0/BoulderBombers<nowiki/>https://github.com/scttgs0/BoulderBombers/releases/tag/alpha_2
|-
|Bombsweeper
|Bomb sweeper port
|beethead
|pgz
|https://discord.com/channels/691915291721990194/855689509520932885/1196352934083035156
|-
|Cosmic
|Shoot 'em up
|beethead
|pgz
|https://discordapp.com/channels/691915291721990194/1054250238308790342/1175982979537969214
|-
|F256-Trek
|Updated Trek, with modern F256 Graphics
|econtrerasd
|basic
|[https://github.com/econtrerasd/Trek-F256/releases/tag/v1.0 https://github.com/econtrerasd/Trek-F256/releases]
|-
|F256 two to the power of eleven
|Port of the puzzle game of 2048
|mgr42
|pgz
|https://github.com/rmsk2/F256_2048<nowiki/>
|-
|fillerup
|Fill 'er Up (WIP)
Qix-like game
|Scott (xDraconian)
|pgx
atari joystick
|https://github.com/scttgs0/Fill-er-up
|-
|FusionDrive
|An outrun type game that also plays a MIDI soundtrack
|Mu0n
|pgz
|wip v0.2, can use a NES pad #1 to move around, or left/right arrow keys currently https://github.com/Mu0n/F256KsimpleCdoodles/tree/main/NoFussDemos
|-
|jewelkeeper
|Sokoban port
|beethead
|pgz
|https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/apps/jewelkeeper.pgz<nowiki/>You can now specify a level file when loading the game <code>/- jewelkeeper.pgz <levels.txt></code>. Find more levels at https://www.sourcecode.se/sokoban/levels.php. Keep in mind the maximum level dimension is 20x15, anything larger will be ignored
|-
|Jr Wördl
|port of Wordle
|AgeAgeEye
|basic
|https://github.com/ageageeye/Superbasic-F256Jr-examples
|-
|kartdemo
|Kart racing game
|SprySloth
|pgz
|https://discord.com/channels/691915291721990194/1225217654487253094/1228246780840513556
|-
|Lair of the Lich King
|Rogue like dungeon crawler. Demo has 3 levels; full has 25+
|Micah
| - lkdemo/lk.pgz
|[https://discord.com/channels/691915291721990194/1230670413361844244/1317256215566487593 1.0 Beta 19 Demo]
|-
|livewire
|Livewire (WIP)
Tempest-like game
|Scott (xDraconian)
|pgx
atari joystick
|https://github.com/scttgs0/Livewire
|-
|Maze-Munch
|Pac-Man clone
|SprySloth
|pgz
|https://github.com/cmassat/Maze-Munch
|-
|pdefense
|Planetary Defense (WIP)
|Scott (xDraconian)
|pgx
mouse
atari joystick
|https://github.com/scttgs0/PlanetaryDefense
|-
|Shanghai/Mahjongg
|A clone of Shanghai. Also known as Mahjongg
|mgr42
|pgz or KUP
mouse needed
|https://github.com/rmsk2/f256_mahjong
|-
|Ski-Jr
|Ski game downhill
|digarok
|basic
|https://github.com/digarok/superbasic-traveler/blob/main/ski-jr.bas
|-
|Track & Field
|Olympic Game by Konami (WIP)
|Scott (xDraconian)
|pgz
atari joystick or keyboard
|
|-
|Tetris
|Good old 80's game
|Daniel Tremblay (Grenouye)
|pgz
atari joystick or keyboard
|https://github.com/dtremblay/c256-tetris/tree/f256k
|}

== Game Jam #01 - April 6th/7th 2024 ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|15puzzle
|Number sort puzzle
|mgr42
|pgz
|https://github.com/rmsk2/f256_15puzzle/releases<nowiki/>
|-
|Flight Simulator
|flying simulator
|sduensin
|pgz
|https://cdn.discordapp.com/attachments/1225481966200029286/1227764847819620454/shotel.pgz
|-
|frisbee
|Frisbee throw past sport game
|dwsJason
|pgz
|https://github.com/dwsJason/f256/blob/develop/merlin32/frisbee/frisbee.pgz
|-
|Impasse
|Shoot 'em up
|digarok
|pgz
|https://discord.com/channels/691915291721990194/1225481966200029286/1227075699895046235
|-
|soccur
|mutliplayer game of soccer
|beethead
|pgz
|executable:https://discord.com/channels/691915291721990194/1225481966200029286/1226808228948611184
source code:
https://discord.com/channels/691915291721990194/1225481966200029286/1226812472069980232
|-
|Trek
|port of classic Star Trek game
|contrerasd
|basic
|https://discord.com/channels/691915291721990194/1225481966200029286/1226727849944289341
|-
|Typing Star
|typing reaction game
|haydenkale
|pgz
|https://github.com/clandrew/typestar
|-
|}

== Game Jam #02 - October 25th-November 1st 2024 ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|Bach's MIDI Hero
|Free MIDI/PSG play + note play tutorial
|Mu0n
|pgz
the MIDI feature requires a F256K2 or F256Jr2; a legacy PSG option also allows F256K and F256Jr to still hear it. Optionally uses a MIDI in controller plugged in.
|https://github.com/Mu0n/F256KsimpleCdoodles/releases/download/v1.2/BachHero.pgz
|-
|f256_snake
|
|mgr42
|pgz. Use cursor keys, Atari joystick or SNES pad to play
|https://github.com/rmsk2/f256_snake
|-
|fnxsnake
|
|silk-neon
|pgz
|https://github.com/ksiondag/fnxsnake
|-
|The Hallow
|
|beethead
|pgz
|https://github.com/noyen1973/FoenixGameJamOct2024
|-
|Halloween Birthday
|
|SprySloth
|pgz
|https://github.com/cmassat/GameJam2024_F256K
|-
|Haunted Mansion
|
|digarok
|superbasic
|https://github.com/digarok/fnxgamejam-haunted-mansion
|-
|Kooyan
|
|Grenouye
|pgz
|https://github.com/dtremblay/kooyan.git
|-
|Spooky Run
|
|dwsJason
|pgz
|https://github.com/dwsJason/spooky
|-
|Trick or Treat
|
|Mike
|pgz
|https://github.com/mcassera/TrickOrTreat
|-
|Ultima III - Exodus
|port
|Minstrel Dragon
|pgz
|https://github.com/minstreldragon/F256_Ultima_3
|-
|Warlock
|remake of 68000 game
|xDraconian
|pgz
atari joystick
DOWN=change_level
UP=jump
UP-LEFT=leap
UP-RIGHT=leap
|https://github.com/scttgs0/Foenix_GameJam_Oct2024
|}

== Game Jam #03 - April 18th-April 27th 2025 ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|Arcade Shanghai v1.2
|Shanghai clone
|contrerasd
|basic, keep the .bas program in root, the rest in the provided ashanghai/ folder
|https://github.com/econtrerasd/ashanghai/releases
|-
|Bawk Bawk Cluck Cluck
|Chicken themed platformer
|beethead
|pgz
|https://github.com/noyen1973/FoenixGameJamApr2025
|-
|BitLadder
|Shoot 'Em Up
|Mu0n
|pgz. For full sound compatibility, a Jr2 or K2 is needed.
Uses 4 sound chips! (PSG, SID, OPL3, MIDI)
|https://mu0n.itch.io/bitladder
|-
|F256_Commando
|Commando port
|SprySloth
|pgz
|https://github.com/cmassat/F256_Commando
|-
|F256_LodeRunner
|Lode Runner port
|Minstrel Dragon
|pgz
|https://github.com/minstreldragon/F256_Loderunner/releases
|-
|Mahjong
|Shangai clone
|mgr42
|pgz
|https://github.com/rmsk2/f256_mahjong/releases
|-
|Quarth
|Block placement arcade game
|Grenouye
|pgz
|https://grenouye.itch.io/f256-quarth
|-
|Skee(ster)-Ball
|
|Mike
|pgz
|https://github.com/mcassera/skeeball256/tree/main
|}

== Game Jam #04 - November-December 2025 ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|H.E.R.O.
|Port of the classic game H.E.R.O.
|Cibee
|pgz
|
|-
|Leaderboard
|Golf game
|xDraconian
|pgz
|
|-
|Pitfall
|Port of the classic Pitfall game from Activision
|MinstrelDragon
|pgz
|
|-
|Track Day
|v1.0 top down race game vs computer controlled opponents
|MikeC
|pgz
|https://mcassera.itch.io/track-day-racing
|}

== Music ==

{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|cozyMIDI
|Plays a SMF with the SAM2695 or VS1053b
|Mu0n
|pgz
|cozyMIDI v2.4 can open and play type 0 and type 1 standard MIDI files (SMF)
needs a Jr2 or K2
with a 2x core at https://github.com/Mu0n/F256KsimpleCdoodles/tree/main/NoFussDemos

run operation 1: just as itself, it will force you to pick a midi file in the 'midi/' folder /- cozymidi

run operation 2: in f/manager, if you put this as <code>midiplayer.pgz</code>in the '_apps/' folder, f/manager will open midi file with it when you launch .mid files.

Program link: https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/cozymidi.pgz
|-
|digestMidi
|converts .mid to .dim
|Mu0n
|pgz
|.mid files are slow to load, parse and prepare for a playback. This tool comes in to convert them into a .dim format that strips out unnecessary MIDI commands and sets it up for timer0 time delays. Works with type 0 and type 1 standard midi files. This tools does the conversion and lets you hear the result.
Find the latest version here: https://github.com/Mu0n/F256MiscGoodies/tree/main/apps
|-
|EdInHisLib
|SID+OPL3 simultaneously
|beethead, ported from xantax
|pgz
|F256 port: https://discordapp.com/channels/691915291721990194/1054249926521016392/1184413356598231120
original: <nowiki>https://csdb.dk/release/?id=170898</nowiki>. Not 100% accurate but close.
|-
|F256amp
|mp3, ogg, wav, wma file playback
|Mu0n
|pgz
|(aka audioplayer.pgz) v2.3 Needs a Jr.2 or K2 since it uses the VS1053b chip.
For a starter collection of .mp3 and other audio files, check the SD curated collection here: https://github.com/Mu0n/F256MiscGoodies/tree/main/SDCard_Collection
run operation 1: just as itself, it will force you to pick an audio file. it expects a <code>media/mp3/</code> folder, but it can live without it and peek into the root instead.

run operation 2: with an argument, it will auto-play it: /- f256amp yourmp3file.mp3

run operation 3: in f/manager, if you put this as <code>audioplayer.pgz</code> in the '_apps/' folder. This lets f/manager automatically open up .mp3, .wav, .ogg, .wma that you press enter on.

Program link: https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/f256amp.pgz
|-
|FireJam
|all chips, music playing with MIDI in
|Mu0n
|pgz
|v1.2 MIDI in and out capable, it will still partially work with a Jr. (PSG, and SID if you have them), a K (PSG, SID, OPL3) and the newest wave 2 Jr2 and K2 (PSG, SID, OPL3, SAM, VS1053b).
Best to use with a MIDI in controller, but it'll be controllable with arrows and space to make notes individually, or the F keys to start beats. https://github.com/Mu0n/F256KsimpleCdoodles/tree/main/NoFussDemos
|-
|jrtracker
|Tracker based in basic and uses the PSG
(considered obsolete, use tracker2)
|contrerasd
|basic
|https://ptb.discord.com/channels/691915291721990194/1008139105386889346/1188292876984143983
|-
|modo
|MOD player using the PSG
|dwsJason and digarok
|pgz
|https://discordapp.com/channels/691915291721990194/855689509520932885/1190723114661859429
|-
|Musik
|Music piece demo using MIDI
|Mike
|pgz
|https://github.com/mcassera/Musik/blob/main/Musik.PGZ<nowiki/>Musikalisches Würfelspiel
Requires a Jr2 or K2 since it uses MIDI
|-
|opl3snooper
|playback of VGM files (that use opl2 and opl3) and MIDI in
|Mu0n
|pgz
|v1.0 mainly plays back vgm files, but you can pause it and snoop around the channel instruments and play up to 18 note polyphony with MIDI in. expects a collection in media/vgm/, or it will browse from the root if it can't find.
It can load a .spl (Simple PLaylist) text file, which is one file per line, including their respective paths.
Requires a Jr2 or K2 with a 2x core to use the extra bank of SRAM.
For a starter collection of .vgm files, check the SD curated collection here: https://github.com/Mu0n/F256MiscGoodies/tree/main/SDCard_Collection
run operation 1: just as itself, it will force you to pick a midi file in the 'media/vgm/' folder

run operation 2: in f/manager (v1.1b9 and up), if you put this as <code>vgmplayer.pgz</code>in the '_apps/' folder, f/manager will open midi file with it when you launch .vgm files.

Program link: https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/opl3snooper.pgz
|-
|opl3tweak
|uses MIDI in, plays 18 channels polyphony in real time to the YMF262 OPL3. Fish for random register values.
|Mu0n
|pgz
|v0.1. Can't save or load instrument definitions yet. Needs a K2 with a MIDI in currently. https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/opl3tweak.pgz
Arrows to move around, + and - keys to incr/decr values or type in a hex value directly under the highlighted position.
|-
|piano
|Plays some PSG notes with the keyboard
|Mu0n
|basic
|https://github.com/Mu0n/F256KbasicBASICdoodles?tab=readme-ov-file#pulse-sound-generator-piano
|-
|playvgm
|plays a headless vgm file with OPL3
|G33kyAndIKnowIt
|pgx
|https://github.com/natebarney/playvgm-f256k
some example music files can be gotten from this post:
[https://discord.com/channels/691915291721990194/975117322836656138/1220366429640065074 https://discord.com/channels/6][https://discord.com/channels/691915291721990194/975117322836656138/1220366429640065074 91915291721990194/975117322836656138/1220366429640065074]

1) open a normal .vgm into a hex editor <nowiki/>and cut out the header bytes from 0x00 to 0x<nowiki/>FF

2) run by first using superbasic's '''''bload''''' '''''"yourmusicfile", $01000'''''
followed by running this program with '''''/- playvgm.pgx'''''
|-
|sidtweak
|uses MIDI in, plays 6 channels polyphony in real time to the dual SID. Fish for random register values.
|Mu0n
|pgz
|v0.1. Can't save or load instrument definitions yet. Needs a K2 with a MIDI in currently. https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/sidtweak.pgz
Arrows to move around, + and - keys to incr/decr values or type in a hex value directly under the highlighted position.
|-
|rawsidplayer
|plays raw PSID files from the HVSC collection, converted by zigreSID
|Mu0n
|pgz
|(formely psidplayer) v0.2 find rawsidplayer.pgz and a starter .rsd file (raw sid dumps). For a starter collection of .rsd files, check the SD curated collection here: https://github.com/Mu0n/F256MiscGoodies/tree/main/SDCard_Collection
extract sid.zip into a folder /sid/ in the root of your SD card, that's where psidplayer.pgz will first look to let you pick a file. failing that, it will fall back to the root folder and let you navigate.

program link:

https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/rawsidplayer.pgz
|-
|tracker2 v1.5
|Like jrtracker.bas, but using both PSGs
|contrerasd
|basic
|https://github.com/econtrerasd/Tracker2/releases
|}

== Uti<nowiki/>lities ==

{| class="wikitable"
|+
!Program
!Descrip<nowiki/>tion
!Author
!Notes on running
!Link
|-
|basic2text
|A simple utility for translating Commodore BASIC (all variants) from its native tokenized file format to a text format that can be opened with SuperBASIC. Does not perform any code translation: all adaptation is up to you.
|Micah
|pgZ
|https://github.com/WartyMN/F256-BasText/releases/latest
|
|-
|dcopy
|A tool to copy files from one drive to another or to/from your PC via RS-232 and a nullmodem cable
|mgr42
|pgz/flash
|https://github.com/rmsk2/f256_dcopy
|
|-
|f/manager
|A general file utility, launcher, and memory viewing program. Dual-panel file/memory browsers; copy between disks, between folders on same disk, and from memory to disk and vice versa; delete, rename, and duplicate files; view files as hex or text (with word-wrap); launch applications and known file types; set the RTC clock; search in RAM and flash. Works with internal SD card and IEC devices such as FNX1591 and Commodore 1541. Can be installed in primary flash position ahead of SuperBASIC or DOS, or at a higher location. Can also be run from disk with "- fm.pgz".
|Micah
|pgZ/flash
|https://github.com/WartyMN/F256-FileManager/releases
|
|-
|f256_reset
|A small utility that lets you reset the machine through this piece of flash software
|mgr42
|flash
|https://github.com/rmsk2/f256_reset
|
|-
|fcart
|A program that allows to write data to flash expansion cartridges
|mgr42
|pgz, on-board and cartridge flash
|https://github.com/rmsk2/cartflash
|
|-
|flashcart
|Allows to wipe a block of flash or write a program to a flash cart, from this basic program from the F256Jr/K
|redfool.
|basic
|https://github.com/Red-Fool/F256_FlashCart/tree/main
|
|-
|flashselect
|Allows to select a program to start from a flash cartridge via a menu
|mgr42
|pgz, on-board and cartridge flash
|https://github.com/rmsk2/flashselect
|
|-
|fonts
|A variety of fonts using the standard F256 character set arrangement. Load with the F256 file manager (f/manager), or your own code.
|Micah
|(not a program)
|[https://github.com/WartyMN/Foenix-Fonts/tree/main https://github.com/WartyMN/Foenix-Fonts]
|
|-
|midiStuff
|Test program for a F256K2 or F256Jr2 that sends MIDI data to the internal sam2695 dream chip that produces MIDI based audio. Also test a keyboard controller plugged in the MIDI in port.
|Mu0n
|pgz
|https://github.com/Mu0n/F256KsimpleCdoodles/blob/main/README.md#midistuff
|
|-
|moreorless
|A text editor for the Foenix 256 line of computers
|mgr42
|pgz
|https://github.com/rmsk2/moreorless/releases/
|
|-
|pgz2flash
|A program for your Linux, Windows or MacOS machine to turn any PGZ or SuperBASIC program into a KUP which can be run from cartridge or onboard flash memory
|mgr42
|Executable for modern computers
|https://github.com/rmsk2/pgz2flash
|
|-
|sidTester
|Simple superbasic program that tests out all 3 voices of the SID1 on the Jr (if populated), K, Jr2 and K2. Ported by Mu0n, made by andy on HackJunk.com https://hackjunk.com/2017/11/07/commodore-64-sid-tester/
|andy
|basic
|https://github.com/Mu0n/F256MiscGoodies/blob/main/apps/sidtester.bas
|
|-
|testsuite.bas
|a series of tests for your F256, video modes and sound chips
|econtrerasd
|basic
|run from the root, https://raw.githubusercontent.com/Mu0n/F256MiscGoodies/refs/heads/main/apps/testsuite.bas
|
|-
|wget<nowiki/>
|<nowiki/>fetches a file from a http address if you have a network connection active. Works with the K and Jr. ESP32 Feather 'huzzah' board. Not meant to be used with the K2 and Jr2 Wiznet chip.
|gadget
|<nowiki/>pgz/flash
|https://github.com/ghackwrench/F256_wget
|
|}

== Sample Code ==

{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|Assembly examples
|Sample programs for several features of the Foenix F256K and Jr.
|mgr42
|read github
|https://github.com/rmsk2/Hello_Foenix256_Jr/blob/main/testprogs.md
|-
|cc65 example
|c example code
|gadget
|read github
|https://github.com/ghackwrench/F256_Jr_Kernel_DOS
|-
|digarok basic stuff
|Lots of basic examples
|digarok
|read github
|https://github.com/digarok/superbasic-traveler/tree/main
|-
|Mu0n's F256K asm doodles
|Some asm examples
|Mu0n
|read github
|https://github.com/Mu0n/F256KsimpleASMdoodles
|-
|Mu0n's F256K basic doodles
|Some basic examples
|Mu0n
|read github
|https://github.com/Mu0n/F256KbasicBASICdoodles
|-
|Mu0n's F256K C doodles
|Some C examples
|Mu0n
|read github
|https://github.com/Mu0n/F256KsimpleCdoodles
|-
|Raúl SQ basic repo
|F256 SuperBASIC Trigonometry
|Raúl SQ
|basic
|https://github.com/raul-sq/FoenixF256K2
|-
|tcp example
|connects to a server and gets typed in text echoed back to you
|gadget
|$2000
|https://github.com/ghackwrench/F256_example_tcp
|}

Software for 6502

2026-01-03T19:39:30Z

1BitFeverDreams: /* Applications */ WildBits Graphic Toolkit rebrand

Note that when an hex address is given, it's meant to instruct as to which address to bload or to send (ie foenixmgr python script) the program (ie a .bin file) to before running it. For extra help on how to run .bin files and almost every possible scheme that has to be used to run program, you can consult this video that's also part of [[Getting Started]], this one: https://www.youtube.com/watch?v=0ShFv89KGDs

Many download links are posts in the main [https://discord.gg/9vjUEGgcUS Foenix Retro Systems discord server] which will require you to join in order to get to them.

A [[Getting Started#Demos Archive|Demo Archive]] was put together in September 2023 to get ready to show to youtubers, some of these are linked once more, in this page.

There's also the Foenix Marketplace website maintained by EMWhite with its own collection of articles and software http://apps.emwhite.org/foenixmarketplace/.

===== Curated SD card collection of games, demos, utilities =====
Here is a download link to a zip file meant to be extracted into the root of an SD card: https://github.com/Mu0n/F256MiscGoodies/tree/main/SDCard_Collection

Best to wipe out your SD card and start anew with the contents of this extracted to root. Micah's file manager doesn't like long lists of files so it really is best to not overdo it. I tried to minimize the files in root, but I couldn't for everything.

Open the readme.txt file with moreorless to see some instructions about the collection. Best to run /- fm first, then open the readme.txt from it

== Applications ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|F256 f/term
|Terminal emulator for F256K and Jr with classic (flat) memory load
|Micah
| - fterm.pgZ or use f/manager
|https://github.com/WartyMN/F256-terminal/blob/main/release/fterm.pgZ
|-
|FoenixTarot
|Tarot card readings in SuperBasic
|Mike
|basic
|https://github.com/mcassera/FoenixTarot/tree/main
|-
|Forthf256
|Forth implementation
|Vasyl
|pgz in its forth/ folder
|https://github.com/VasylTsv/ForthX16
|-
|WildBits Graphic Toolkit
|(fmr. F256-GraphicToolkit) Sprite editor, Tilemap editor, Font editor + misc tools
|econtrerasd
|basic
|https://github.com/econtrerasd/F256-GraphicToolkit/releases
|}

== Demos ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|badapple
|A 80x60 textmode port of Bad Apple, uses the VS1053b for quality mp3 audio. Needs a Jr2 or K2!
|Mu0n
|pgz*
|*unzip badapple.zip into the root of your SD card. If done right, the 3 files within will be in the demos/ folder. The program expects its data file there when it runs. https://github.com/Mu0n/F256MiscGoodies/blob/main/apps/badapple.zip
|-
|balls
|Draw a good quantity of multiplexed sprites, fast. Balls bouncing around
|celton
|pgz
|https://github.com/FoenixRetro/demos/blob/main/MultiplexedSprites.md
|-
|F256Archon
|Splash screen intro, plays MIDI using the SAM2695, requires a K2 or Jr2
|Mu0n
|pgz
|https://github.com/Mu0n/F256Archon/releases
|-
|f256_life
|An implementation of Conway's game of life
|mgr42
|pgz
|https://github.com/rmsk2/f256_life
|-
|F256 Mandelbrot
|Draws Mandelbrot set fast (5 mins) using coprocessor math. Allows to zoom into the set.
|mgr42
|uses basic loader
|https://github.com/rmsk2/F256_Mandelbrot
|-
|F256ShowCase
|Shows sliding tiling graphics, moves with joystick
|eriktier
|$0000
|https://github.com/pig-games/F256Showcase
|-
|fnxmas23
|PSG mod music, scrolling text, sound effects, must see demo!
|dwsJason and digarok
|pgz
|https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/apps/xmas24_k2.pgz revised version that can run on wave 2 Jr2 and K2 as well
|-
|foenixmas23
|Xmas 2023 demo with SID music from the classic 1983 C64 xmas demo
|EMWhite
|uses basic loader
|http://apps.emwhite.org/shared-files/815/?foenixmas23.zip
|-
|livingworlds
|Living Worlds, a port of a color cycling by Mark Ferrari, ported here on the F256 by haydenkale
|haydenkale
|$0000
|https://github.com/clandrew/livingworlds/tree/e4532e0d530b76ccb90368fdf5ad10bfa2deeb12
|-
|mandel
|Will draw a mandelbrot set in 3 hours, more useful as a stability test than a useful fractal program
|Mu0n
|basic
|https://github.com/Mu0n/F256KbasicBASICdoodles?tab=readme-ov-file#fractal
|-
|wormhole
|Shows a fast wireframe animation of a wormhole
|haydenkale
|pgz or bin at $0000
|https://github.com/clandrew/wormhole?tab=readme-ov-file
|}

== Games ==

{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|bbombers
|Boulder Bombers (Alpha-2) Clone of Canyon Bombers
|Scott (xDraconian)
|pgx
atari joystick
|https://github.com/scttgs0/BoulderBombers<nowiki/>https://github.com/scttgs0/BoulderBombers/releases/tag/alpha_2
|-
|Bombsweeper
|Bomb sweeper port
|beethead
|pgz
|https://discord.com/channels/691915291721990194/855689509520932885/1196352934083035156
|-
|Cosmic
|Shoot 'em up
|beethead
|pgz
|https://discordapp.com/channels/691915291721990194/1054250238308790342/1175982979537969214
|-
|F256-Trek
|Updated Trek, with modern F256 Graphics
|econtrerasd
|basic
|[https://github.com/econtrerasd/Trek-F256/releases/tag/v1.0 https://github.com/econtrerasd/Trek-F256/releases]
|-
|F256 two to the power of eleven
|Port of the puzzle game of 2048
|mgr42
|pgz
|https://github.com/rmsk2/F256_2048<nowiki/>
|-
|fillerup
|Fill 'er Up (WIP)
Qix-like game
|Scott (xDraconian)
|pgx
atari joystick
|https://github.com/scttgs0/Fill-er-up
|-
|FusionDrive
|An outrun type game that also plays a MIDI soundtrack
|Mu0n
|pgz
|wip v0.2, can use a NES pad #1 to move around, or left/right arrow keys currently https://github.com/Mu0n/F256KsimpleCdoodles/tree/main/NoFussDemos
|-
|jewelkeeper
|Sokoban port
|beethead
|pgz
|https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/apps/jewelkeeper.pgz<nowiki/>You can now specify a level file when loading the game <code>/- jewelkeeper.pgz <levels.txt></code>. Find more levels at https://www.sourcecode.se/sokoban/levels.php. Keep in mind the maximum level dimension is 20x15, anything larger will be ignored
|-
|Jr Wördl
|port of Wordle
|AgeAgeEye
|basic
|https://github.com/ageageeye/Superbasic-F256Jr-examples
|-
|kartdemo
|Kart racing game
|SprySloth
|pgz
|https://discord.com/channels/691915291721990194/1225217654487253094/1228246780840513556
|-
|Lair of the Lich King
|Rogue like dungeon crawler. Demo has 3 levels; full has 25+
|Micah
| - lkdemo/lk.pgz
|[https://discord.com/channels/691915291721990194/1230670413361844244/1317256215566487593 1.0 Beta 19 Demo]
|-
|livewire
|Livewire (WIP)
Tempest-like game
|Scott (xDraconian)
|pgx
atari joystick
|https://github.com/scttgs0/Livewire
|-
|Maze-Munch
|Pac-Man clone
|SprySloth
|pgz
|https://github.com/cmassat/Maze-Munch
|-
|pdefense
|Planetary Defense (WIP)
|Scott (xDraconian)
|pgx
mouse
atari joystick
|https://github.com/scttgs0/PlanetaryDefense
|-
|Shanghai/Mahjongg
|A clone of Shanghai. Also known as Mahjongg
|mgr42
|pgz or KUP
mouse needed
|https://github.com/rmsk2/f256_mahjong
|-
|Ski-Jr
|Ski game downhill
|digarok
|basic
|https://github.com/digarok/superbasic-traveler/blob/main/ski-jr.bas
|-
|Track & Field
|Olympic Game by Konami (WIP)
|Scott (xDraconian)
|pgz
atari joystick or keyboard
|
|-
|Tetris
|Good old 80's game
|Daniel Tremblay (Grenouye)
|pgz
atari joystick or keyboard
|https://github.com/dtremblay/c256-tetris/tree/f256k
|}

== Game Jam #01 - April 6th/7th 2024 ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|15puzzle
|Number sort puzzle
|mgr42
|pgz
|https://github.com/rmsk2/f256_15puzzle/releases<nowiki/>
|-
|Flight Simulator
|flying simulator
|sduensin
|pgz
|https://cdn.discordapp.com/attachments/1225481966200029286/1227764847819620454/shotel.pgz
|-
|frisbee
|Frisbee throw past sport game
|dwsJason
|pgz
|https://github.com/dwsJason/f256/blob/develop/merlin32/frisbee/frisbee.pgz
|-
|Impasse
|Shoot 'em up
|digarok
|pgz
|https://discord.com/channels/691915291721990194/1225481966200029286/1227075699895046235
|-
|soccur
|mutliplayer game of soccer
|beethead
|pgz
|executable:https://discord.com/channels/691915291721990194/1225481966200029286/1226808228948611184
source code:
https://discord.com/channels/691915291721990194/1225481966200029286/1226812472069980232
|-
|Trek
|port of classic Star Trek game
|contrerasd
|basic
|https://discord.com/channels/691915291721990194/1225481966200029286/1226727849944289341
|-
|Typing Star
|typing reaction game
|haydenkale
|pgz
|https://github.com/clandrew/typestar
|-
|}

== Game Jam #02 - October 25th-November 1st 2024 ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|Bach's MIDI Hero
|Free MIDI/PSG play + note play tutorial
|Mu0n
|pgz
the MIDI feature requires a F256K2 or F256Jr2; a legacy PSG option also allows F256K and F256Jr to still hear it. Optionally uses a MIDI in controller plugged in.
|https://github.com/Mu0n/F256KsimpleCdoodles/releases/download/v1.2/BachHero.pgz
|-
|f256_snake
|
|mgr42
|pgz. Use cursor keys, Atari joystick or SNES pad to play
|https://github.com/rmsk2/f256_snake
|-
|fnxsnake
|
|silk-neon
|pgz
|https://github.com/ksiondag/fnxsnake
|-
|The Hallow
|
|beethead
|pgz
|https://github.com/noyen1973/FoenixGameJamOct2024
|-
|Halloween Birthday
|
|SprySloth
|pgz
|https://github.com/cmassat/GameJam2024_F256K
|-
|Haunted Mansion
|
|digarok
|superbasic
|https://github.com/digarok/fnxgamejam-haunted-mansion
|-
|Kooyan
|
|Grenouye
|pgz
|https://github.com/dtremblay/kooyan.git
|-
|Spooky Run
|
|dwsJason
|pgz
|https://github.com/dwsJason/spooky
|-
|Trick or Treat
|
|Mike
|pgz
|https://github.com/mcassera/TrickOrTreat
|-
|Ultima III - Exodus
|port
|Minstrel Dragon
|pgz
|https://github.com/minstreldragon/F256_Ultima_3
|-
|Warlock
|remake of 68000 game
|xDraconian
|pgz
atari joystick
DOWN=change_level
UP=jump
UP-LEFT=leap
UP-RIGHT=leap
|https://github.com/scttgs0/Foenix_GameJam_Oct2024
|}

== Game Jam #03 - April 18th-April 27th 2025 ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|Arcade Shanghai v1.2
|Shanghai clone
|contrerasd
|basic, keep the .bas program in root, the rest in the provided ashanghai/ folder
|https://github.com/econtrerasd/ashanghai/releases
|-
|Bawk Bawk Cluck Cluck
|Chicken themed platformer
|beethead
|pgz
|https://github.com/noyen1973/FoenixGameJamApr2025
|-
|BitLadder
|Shoot 'Em Up
|Mu0n
|pgz. For full sound compatibility, a Jr2 or K2 is needed.
Uses 4 sound chips! (PSG, SID, OPL3, MIDI)
|https://mu0n.itch.io/bitladder
|-
|F256_Commando
|Commando port
|SprySloth
|pgz
|https://github.com/cmassat/F256_Commando
|-
|F256_LodeRunner
|Lode Runner port
|Minstrel Dragon
|pgz
|https://github.com/minstreldragon/F256_Loderunner/releases
|-
|Mahjong
|Shangai clone
|mgr42
|pgz
|https://github.com/rmsk2/f256_mahjong/releases
|-
|Quarth
|Block placement arcade game
|Grenouye
|pgz
|https://grenouye.itch.io/f256-quarth
|-
|Skee(ster)-Ball
|
|Mike
|pgz
|https://github.com/mcassera/skeeball256/tree/main
|}

== Music ==

{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|cozyMIDI
|Plays a SMF with the SAM2695 or VS1053b
|Mu0n
|pgz
|cozyMIDI v2.4 can open and play type 0 and type 1 standard MIDI files (SMF)
needs a Jr2 or K2
with a 2x core at https://github.com/Mu0n/F256KsimpleCdoodles/tree/main/NoFussDemos

run operation 1: just as itself, it will force you to pick a midi file in the 'midi/' folder /- cozymidi

run operation 2: in f/manager, if you put this as <code>midiplayer.pgz</code>in the '_apps/' folder, f/manager will open midi file with it when you launch .mid files.

Program link: https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/cozymidi.pgz
|-
|digestMidi
|converts .mid to .dim
|Mu0n
|pgz
|.mid files are slow to load, parse and prepare for a playback. This tool comes in to convert them into a .dim format that strips out unnecessary MIDI commands and sets it up for timer0 time delays. Works with type 0 and type 1 standard midi files. This tools does the conversion and lets you hear the result.
Find the latest version here: https://github.com/Mu0n/F256MiscGoodies/tree/main/apps
|-
|EdInHisLib
|SID+OPL3 simultaneously
|beethead, ported from xantax
|pgz
|F256 port: https://discordapp.com/channels/691915291721990194/1054249926521016392/1184413356598231120
original: <nowiki>https://csdb.dk/release/?id=170898</nowiki>. Not 100% accurate but close.
|-
|F256amp
|mp3, ogg, wav, wma file playback
|Mu0n
|pgz
|(aka audioplayer.pgz) v2.3 Needs a Jr.2 or K2 since it uses the VS1053b chip.
For a starter collection of .mp3 and other audio files, check the SD curated collection here: https://github.com/Mu0n/F256MiscGoodies/tree/main/SDCard_Collection
run operation 1: just as itself, it will force you to pick an audio file. it expects a <code>media/mp3/</code> folder, but it can live without it and peek into the root instead.

run operation 2: with an argument, it will auto-play it: /- f256amp yourmp3file.mp3

run operation 3: in f/manager, if you put this as <code>audioplayer.pgz</code> in the '_apps/' folder. This lets f/manager automatically open up .mp3, .wav, .ogg, .wma that you press enter on.

Program link: https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/f256amp.pgz
|-
|FireJam
|all chips, music playing with MIDI in
|Mu0n
|pgz
|v1.2 MIDI in and out capable, it will still partially work with a Jr. (PSG, and SID if you have them), a K (PSG, SID, OPL3) and the newest wave 2 Jr2 and K2 (PSG, SID, OPL3, SAM, VS1053b).
Best to use with a MIDI in controller, but it'll be controllable with arrows and space to make notes individually, or the F keys to start beats. https://github.com/Mu0n/F256KsimpleCdoodles/tree/main/NoFussDemos
|-
|jrtracker
|Tracker based in basic and uses the PSG
(considered obsolete, use tracker2)
|contrerasd
|basic
|https://ptb.discord.com/channels/691915291721990194/1008139105386889346/1188292876984143983
|-
|modo
|MOD player using the PSG
|dwsJason and digarok
|pgz
|https://discordapp.com/channels/691915291721990194/855689509520932885/1190723114661859429
|-
|Musik
|Music piece demo using MIDI
|Mike
|pgz
|https://github.com/mcassera/Musik/blob/main/Musik.PGZ<nowiki/>Musikalisches Würfelspiel
Requires a Jr2 or K2 since it uses MIDI
|-
|opl3snooper
|playback of VGM files (that use opl2 and opl3) and MIDI in
|Mu0n
|pgz
|v1.0 mainly plays back vgm files, but you can pause it and snoop around the channel instruments and play up to 18 note polyphony with MIDI in. expects a collection in media/vgm/, or it will browse from the root if it can't find.
It can load a .spl (Simple PLaylist) text file, which is one file per line, including their respective paths.
Requires a Jr2 or K2 with a 2x core to use the extra bank of SRAM.
For a starter collection of .vgm files, check the SD curated collection here: https://github.com/Mu0n/F256MiscGoodies/tree/main/SDCard_Collection
run operation 1: just as itself, it will force you to pick a midi file in the 'media/vgm/' folder

run operation 2: in f/manager (v1.1b9 and up), if you put this as <code>vgmplayer.pgz</code>in the '_apps/' folder, f/manager will open midi file with it when you launch .vgm files.

Program link: https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/opl3snooper.pgz
|-
|opl3tweak
|uses MIDI in, plays 18 channels polyphony in real time to the YMF262 OPL3. Fish for random register values.
|Mu0n
|pgz
|v0.1. Can't save or load instrument definitions yet. Needs a K2 with a MIDI in currently. https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/opl3tweak.pgz
Arrows to move around, + and - keys to incr/decr values or type in a hex value directly under the highlighted position.
|-
|piano
|Plays some PSG notes with the keyboard
|Mu0n
|basic
|https://github.com/Mu0n/F256KbasicBASICdoodles?tab=readme-ov-file#pulse-sound-generator-piano
|-
|playvgm
|plays a headless vgm file with OPL3
|G33kyAndIKnowIt
|pgx
|https://github.com/natebarney/playvgm-f256k
some example music files can be gotten from this post:
[https://discord.com/channels/691915291721990194/975117322836656138/1220366429640065074 https://discord.com/channels/6][https://discord.com/channels/691915291721990194/975117322836656138/1220366429640065074 91915291721990194/975117322836656138/1220366429640065074]

1) open a normal .vgm into a hex editor <nowiki/>and cut out the header bytes from 0x00 to 0x<nowiki/>FF

2) run by first using superbasic's '''''bload''''' '''''"yourmusicfile", $01000'''''
followed by running this program with '''''/- playvgm.pgx'''''
|-
|sidtweak
|uses MIDI in, plays 6 channels polyphony in real time to the dual SID. Fish for random register values.
|Mu0n
|pgz
|v0.1. Can't save or load instrument definitions yet. Needs a K2 with a MIDI in currently. https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/sidtweak.pgz
Arrows to move around, + and - keys to incr/decr values or type in a hex value directly under the highlighted position.
|-
|rawsidplayer
|plays raw PSID files from the HVSC collection, converted by zigreSID
|Mu0n
|pgz
|(formely psidplayer) v0.2 find rawsidplayer.pgz and a starter .rsd file (raw sid dumps). For a starter collection of .rsd files, check the SD curated collection here: https://github.com/Mu0n/F256MiscGoodies/tree/main/SDCard_Collection
extract sid.zip into a folder /sid/ in the root of your SD card, that's where psidplayer.pgz will first look to let you pick a file. failing that, it will fall back to the root folder and let you navigate.

program link:

https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/rawsidplayer.pgz
|-
|tracker2 v1.5
|Like jrtracker.bas, but using both PSGs
|contrerasd
|basic
|https://github.com/econtrerasd/Tracker2/releases
|}

== Uti<nowiki/>lities ==

{| class="wikitable"
|+
!Program
!Descrip<nowiki/>tion
!Author
!Notes on running
!Link
|-
|basic2text
|A simple utility for translating Commodore BASIC (all variants) from its native tokenized file format to a text format that can be opened with SuperBASIC. Does not perform any code translation: all adaptation is up to you.
|Micah
|pgZ
|https://github.com/WartyMN/F256-BasText/releases/latest
|
|-
|dcopy
|A tool to copy files from one drive to another or to/from your PC via RS-232 and a nullmodem cable
|mgr42
|pgz/flash
|https://github.com/rmsk2/f256_dcopy
|
|-
|f/manager
|A general file utility, launcher, and memory viewing program. Dual-panel file/memory browsers; copy between disks, between folders on same disk, and from memory to disk and vice versa; delete, rename, and duplicate files; view files as hex or text (with word-wrap); launch applications and known file types; set the RTC clock; search in RAM and flash. Works with internal SD card and IEC devices such as FNX1591 and Commodore 1541. Can be installed in primary flash position ahead of SuperBASIC or DOS, or at a higher location. Can also be run from disk with "- fm.pgz".
|Micah
|pgZ/flash
|https://github.com/WartyMN/F256-FileManager/releases
|
|-
|f256_reset
|A small utility that lets you reset the machine through this piece of flash software
|mgr42
|flash
|https://github.com/rmsk2/f256_reset
|
|-
|fcart
|A program that allows to write data to flash expansion cartridges
|mgr42
|pgz, on-board and cartridge flash
|https://github.com/rmsk2/cartflash
|
|-
|flashcart
|Allows to wipe a block of flash or write a program to a flash cart, from this basic program from the F256Jr/K
|redfool.
|basic
|https://github.com/Red-Fool/F256_FlashCart/tree/main
|
|-
|flashselect
|Allows to select a program to start from a flash cartridge via a menu
|mgr42
|pgz, on-board and cartridge flash
|https://github.com/rmsk2/flashselect
|
|-
|fonts
|A variety of fonts using the standard F256 character set arrangement. Load with the F256 file manager (f/manager), or your own code.
|Micah
|(not a program)
|[https://github.com/WartyMN/Foenix-Fonts/tree/main https://github.com/WartyMN/Foenix-Fonts]
|
|-
|midiStuff
|Test program for a F256K2 or F256Jr2 that sends MIDI data to the internal sam2695 dream chip that produces MIDI based audio. Also test a keyboard controller plugged in the MIDI in port.
|Mu0n
|pgz
|https://github.com/Mu0n/F256KsimpleCdoodles/blob/main/README.md#midistuff
|
|-
|moreorless
|A text editor for the Foenix 256 line of computers
|mgr42
|pgz
|https://github.com/rmsk2/moreorless/releases/
|
|-
|pgz2flash
|A program for your Linux, Windows or MacOS machine to turn any PGZ or SuperBASIC program into a KUP which can be run from cartridge or onboard flash memory
|mgr42
|Executable for modern computers
|https://github.com/rmsk2/pgz2flash
|
|-
|sidTester
|Simple superbasic program that tests out all 3 voices of the SID1 on the Jr (if populated), K, Jr2 and K2. Ported by Mu0n, made by andy on HackJunk.com https://hackjunk.com/2017/11/07/commodore-64-sid-tester/
|andy
|basic
|https://github.com/Mu0n/F256MiscGoodies/blob/main/apps/sidtester.bas
|
|-
|testsuite.bas
|a series of tests for your F256, video modes and sound chips
|econtrerasd
|basic
|run from the root, https://raw.githubusercontent.com/Mu0n/F256MiscGoodies/refs/heads/main/apps/testsuite.bas
|
|-
|wget<nowiki/>
|<nowiki/>fetches a file from a http address if you have a network connection active. Works with the K and Jr. ESP32 Feather 'huzzah' board. Not meant to be used with the K2 and Jr2 Wiznet chip.
|gadget
|<nowiki/>pgz/flash
|https://github.com/ghackwrench/F256_wget
|
|}

== Sample Code ==

{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|Assembly examples
|Sample programs for several features of the Foenix F256K and Jr.
|mgr42
|read github
|https://github.com/rmsk2/Hello_Foenix256_Jr/blob/main/testprogs.md
|-
|cc65 example
|c example code
|gadget
|read github
|https://github.com/ghackwrench/F256_Jr_Kernel_DOS
|-
|digarok basic stuff
|Lots of basic examples
|digarok
|read github
|https://github.com/digarok/superbasic-traveler/tree/main
|-
|Mu0n's F256K asm doodles
|Some asm examples
|Mu0n
|read github
|https://github.com/Mu0n/F256KsimpleASMdoodles
|-
|Mu0n's F256K basic doodles
|Some basic examples
|Mu0n
|read github
|https://github.com/Mu0n/F256KbasicBASICdoodles
|-
|Mu0n's F256K C doodles
|Some C examples
|Mu0n
|read github
|https://github.com/Mu0n/F256KsimpleCdoodles
|-
|Raúl SQ basic repo
|F256 SuperBASIC Trigonometry
|Raúl SQ
|basic
|https://github.com/raul-sq/FoenixF256K2
|-
|tcp example
|connects to a server and gets typed in text echoed back to you
|gadget
|$2000
|https://github.com/ghackwrench/F256_example_tcp
|}

Firmware

2026-01-01T15:39:37Z

1BitFeverDreams: /* Video tutorial: */

The Foenix F256K, Jr., K2 and Jr2 computers contain 512K of flash memory which is intended to store software which should be available to the user without any media like SD-cards or IEC drives present. Think of it like a space traditionally occupied by ROM chips of 80's computers containing critical, often used programs and routines, but instead of being very rarely updated with scarce ROM chip revisions, it can be quickly updated with firmware revisions using the FoenixMgr python scripts.

'''Important Note''': for the F256K2, each core has its own dedicated area of 512K of flash memory. When switching to a new core, a separate dedicated area of 512K exists for that core and there's an expectation that the process of flashing the firmware has to be done for it.

This collection of software can be changed by the user by simply reprogramming the flash "ROM". At the moment (2025+) the following applications are stored in flash as a default loadout:
{| class="wikitable"
|+Collection of 6502/65816 firmware programs as of firmware release version 2025.13
!Absolute Block* in Memory Map
!Block* Offset in onboard Flash
!Name of program
!Description
|-
|0x40
|0x00
|'''''reserved'''''
|
|-
|0x41
|0x01
|xdev
|trampoline program meant to react to developper scripts from [[FoenixMgr]]: pcopy, runpgz, runpgx
|-
|0x42 to 0x45
|0x02 to 0x05
|superbasic
|if xdev has nothing to react to, superbasic is your default startup program
|-
|0x46
|0x06
|dos
|minimalistic file management and info shell
|-
|0x47
|0x07
|'''''free'''''
|
|-
|0x48
|0x08
|fcart
|allows a user to flash the 256K Flast Cart with 8kb prepared blocks. See [[CartFlasher|this for usage]]
|-
|0x49
|0x09
|'''free'''
|
|-
|0x4A
|0x0A
|help
|text help on screen for superbasic programming
|-
|0x4B to 0x4E
|0x0B to 0x0E
|'''''free'''''
|
|-
|0x4F
|0x0F
|wget
|web get, works only for gen1 K and Jr equipped with a feather wifi board
|-
|0x50 to 0x56
|0x10 to 0x16
|fm
|f/manager - a rather feature rich file manipulation, program launcher and memory exploration software
|-
|0x57
|0x17
|'''''free'''''
|
|-
|0x58 to 0x5B
|0x18 to 0x1B
|mless
|moreorless - a text editor. See [[Moreorless|here for more information.]]
|-
|0x5D to 0x7B
|0x1D to 0x3B
|'''''free'''''
|
|-
|0x7C to 0x7F
|0x3C to 0x3F
|microkernel
|the microkernel, gadget's masterpiece used by many programs
|}
<nowiki>*</nowiki>Block: each block of flash memory is 8kb is size

To reprogram the flash, you can start with the [https://github.com/FoenixRetro/f256-firmware/releases official firmware releases in this github.]

This repo is part the [https://github.com/FoenixRetro FoenixRetro] Github organisation which in turn is an attempt to gather forks of all projects which are part of the firmware and other resources relevant for the Foenix F256 new retro computers.

There are now two firmware loads available: Gen1 - for K and Jr and Gen2 - for K2 and Jr2. The only difference between these loads is the superbasic part of the firmware, in order to have a properly identified superbasic startup screen that reflects the exact computer and generation in the logo.

====== Video tutorial: ======
A part of a tutorial video covers updating the firmware as a follow up step to updating the FPGA core, check it at 6:45 and on.

<youtube>pOab0ocKqac</youtube>

==== 6809 firmware: ====
This core has specialized firmware - it is best to ask around in the appropriate channels of the [https://discord.gg/9vjUEGgcUS Foenix discord].

Firmware

2026-01-01T15:38:58Z

1BitFeverDreams: /* Video tutorial: */

The Foenix F256K, Jr., K2 and Jr2 computers contain 512K of flash memory which is intended to store software which should be available to the user without any media like SD-cards or IEC drives present. Think of it like a space traditionally occupied by ROM chips of 80's computers containing critical, often used programs and routines, but instead of being very rarely updated with scarce ROM chip revisions, it can be quickly updated with firmware revisions using the FoenixMgr python scripts.

'''Important Note''': for the F256K2, each core has its own dedicated area of 512K of flash memory. When switching to a new core, a separate dedicated area of 512K exists for that core and there's an expectation that the process of flashing the firmware has to be done for it.

This collection of software can be changed by the user by simply reprogramming the flash "ROM". At the moment (2025+) the following applications are stored in flash as a default loadout:
{| class="wikitable"
|+Collection of 6502/65816 firmware programs as of firmware release version 2025.13
!Absolute Block* in Memory Map
!Block* Offset in onboard Flash
!Name of program
!Description
|-
|0x40
|0x00
|'''''reserved'''''
|
|-
|0x41
|0x01
|xdev
|trampoline program meant to react to developper scripts from [[FoenixMgr]]: pcopy, runpgz, runpgx
|-
|0x42 to 0x45
|0x02 to 0x05
|superbasic
|if xdev has nothing to react to, superbasic is your default startup program
|-
|0x46
|0x06
|dos
|minimalistic file management and info shell
|-
|0x47
|0x07
|'''''free'''''
|
|-
|0x48
|0x08
|fcart
|allows a user to flash the 256K Flast Cart with 8kb prepared blocks. See [[CartFlasher|this for usage]]
|-
|0x49
|0x09
|'''free'''
|
|-
|0x4A
|0x0A
|help
|text help on screen for superbasic programming
|-
|0x4B to 0x4E
|0x0B to 0x0E
|'''''free'''''
|
|-
|0x4F
|0x0F
|wget
|web get, works only for gen1 K and Jr equipped with a feather wifi board
|-
|0x50 to 0x56
|0x10 to 0x16
|fm
|f/manager - a rather feature rich file manipulation, program launcher and memory exploration software
|-
|0x57
|0x17
|'''''free'''''
|
|-
|0x58 to 0x5B
|0x18 to 0x1B
|mless
|moreorless - a text editor. See [[Moreorless|here for more information.]]
|-
|0x5D to 0x7B
|0x1D to 0x3B
|'''''free'''''
|
|-
|0x7C to 0x7F
|0x3C to 0x3F
|microkernel
|the microkernel, gadget's masterpiece used by many programs
|}
<nowiki>*</nowiki>Block: each block of flash memory is 8kb is size

To reprogram the flash, you can start with the [https://github.com/FoenixRetro/f256-firmware/releases official firmware releases in this github.]

This repo is part the [https://github.com/FoenixRetro FoenixRetro] Github organisation which in turn is an attempt to gather forks of all projects which are part of the firmware and other resources relevant for the Foenix F256 new retro computers.

There are now two firmware loads available: Gen1 - for K and Jr and Gen2 - for K2 and Jr2. The only difference between these loads is the superbasic part of the firmware, in order to have a properly identified superbasic startup screen that reflects the exact computer and generation in the logo.

====== Video tutorial: ======
A part of a tutorial video covers updating the firmware as a follow up step to updating the FPGA core, check it at 4:05 and on.

<youtube>pOab0ocKqac</youtube>

==== 6809 firmware: ====
This core has specialized firmware - it is best to ask around in the appropriate channels of the [https://discord.gg/9vjUEGgcUS Foenix discord].

Firmware

2026-01-01T15:38:10Z

1BitFeverDreams: /* Video tutorial: */

The Foenix F256K, Jr., K2 and Jr2 computers contain 512K of flash memory which is intended to store software which should be available to the user without any media like SD-cards or IEC drives present. Think of it like a space traditionally occupied by ROM chips of 80's computers containing critical, often used programs and routines, but instead of being very rarely updated with scarce ROM chip revisions, it can be quickly updated with firmware revisions using the FoenixMgr python scripts.

'''Important Note''': for the F256K2, each core has its own dedicated area of 512K of flash memory. When switching to a new core, a separate dedicated area of 512K exists for that core and there's an expectation that the process of flashing the firmware has to be done for it.

This collection of software can be changed by the user by simply reprogramming the flash "ROM". At the moment (2025+) the following applications are stored in flash as a default loadout:
{| class="wikitable"
|+Collection of 6502/65816 firmware programs as of firmware release version 2025.13
!Absolute Block* in Memory Map
!Block* Offset in onboard Flash
!Name of program
!Description
|-
|0x40
|0x00
|'''''reserved'''''
|
|-
|0x41
|0x01
|xdev
|trampoline program meant to react to developper scripts from [[FoenixMgr]]: pcopy, runpgz, runpgx
|-
|0x42 to 0x45
|0x02 to 0x05
|superbasic
|if xdev has nothing to react to, superbasic is your default startup program
|-
|0x46
|0x06
|dos
|minimalistic file management and info shell
|-
|0x47
|0x07
|'''''free'''''
|
|-
|0x48
|0x08
|fcart
|allows a user to flash the 256K Flast Cart with 8kb prepared blocks. See [[CartFlasher|this for usage]]
|-
|0x49
|0x09
|'''free'''
|
|-
|0x4A
|0x0A
|help
|text help on screen for superbasic programming
|-
|0x4B to 0x4E
|0x0B to 0x0E
|'''''free'''''
|
|-
|0x4F
|0x0F
|wget
|web get, works only for gen1 K and Jr equipped with a feather wifi board
|-
|0x50 to 0x56
|0x10 to 0x16
|fm
|f/manager - a rather feature rich file manipulation, program launcher and memory exploration software
|-
|0x57
|0x17
|'''''free'''''
|
|-
|0x58 to 0x5B
|0x18 to 0x1B
|mless
|moreorless - a text editor. See [[Moreorless|here for more information.]]
|-
|0x5D to 0x7B
|0x1D to 0x3B
|'''''free'''''
|
|-
|0x7C to 0x7F
|0x3C to 0x3F
|microkernel
|the microkernel, gadget's masterpiece used by many programs
|}
<nowiki>*</nowiki>Block: each block of flash memory is 8kb is size

To reprogram the flash, you can start with the [https://github.com/FoenixRetro/f256-firmware/releases official firmware releases in this github.]

This repo is part the [https://github.com/FoenixRetro FoenixRetro] Github organisation which in turn is an attempt to gather forks of all projects which are part of the firmware and other resources relevant for the Foenix F256 new retro computers.

There are now two firmware loads available: Gen1 - for K and Jr and Gen2 - for K2 and Jr2. The only difference between these loads is the superbasic part of the firmware, in order to have a properly identified superbasic startup screen that reflects the exact computer and generation in the logo.

====== Video tutorial: ======
A timestamped part of a tutorial video covers updating the firmware as a follow up step to updating the FPGA core.

<youtube>dzyMjtC-yjFTxbgu&t=405</youtube>

==== 6809 firmware: ====
This core has specialized firmware - it is best to ask around in the appropriate channels of the [https://discord.gg/9vjUEGgcUS Foenix discord].

Firmware

2026-01-01T15:37:09Z

1BitFeverDreams:

The Foenix F256K, Jr., K2 and Jr2 computers contain 512K of flash memory which is intended to store software which should be available to the user without any media like SD-cards or IEC drives present. Think of it like a space traditionally occupied by ROM chips of 80's computers containing critical, often used programs and routines, but instead of being very rarely updated with scarce ROM chip revisions, it can be quickly updated with firmware revisions using the FoenixMgr python scripts.

'''Important Note''': for the F256K2, each core has its own dedicated area of 512K of flash memory. When switching to a new core, a separate dedicated area of 512K exists for that core and there's an expectation that the process of flashing the firmware has to be done for it.

This collection of software can be changed by the user by simply reprogramming the flash "ROM". At the moment (2025+) the following applications are stored in flash as a default loadout:
{| class="wikitable"
|+Collection of 6502/65816 firmware programs as of firmware release version 2025.13
!Absolute Block* in Memory Map
!Block* Offset in onboard Flash
!Name of program
!Description
|-
|0x40
|0x00
|'''''reserved'''''
|
|-
|0x41
|0x01
|xdev
|trampoline program meant to react to developper scripts from [[FoenixMgr]]: pcopy, runpgz, runpgx
|-
|0x42 to 0x45
|0x02 to 0x05
|superbasic
|if xdev has nothing to react to, superbasic is your default startup program
|-
|0x46
|0x06
|dos
|minimalistic file management and info shell
|-
|0x47
|0x07
|'''''free'''''
|
|-
|0x48
|0x08
|fcart
|allows a user to flash the 256K Flast Cart with 8kb prepared blocks. See [[CartFlasher|this for usage]]
|-
|0x49
|0x09
|'''free'''
|
|-
|0x4A
|0x0A
|help
|text help on screen for superbasic programming
|-
|0x4B to 0x4E
|0x0B to 0x0E
|'''''free'''''
|
|-
|0x4F
|0x0F
|wget
|web get, works only for gen1 K and Jr equipped with a feather wifi board
|-
|0x50 to 0x56
|0x10 to 0x16
|fm
|f/manager - a rather feature rich file manipulation, program launcher and memory exploration software
|-
|0x57
|0x17
|'''''free'''''
|
|-
|0x58 to 0x5B
|0x18 to 0x1B
|mless
|moreorless - a text editor. See [[Moreorless|here for more information.]]
|-
|0x5D to 0x7B
|0x1D to 0x3B
|'''''free'''''
|
|-
|0x7C to 0x7F
|0x3C to 0x3F
|microkernel
|the microkernel, gadget's masterpiece used by many programs
|}
<nowiki>*</nowiki>Block: each block of flash memory is 8kb is size

To reprogram the flash, you can start with the [https://github.com/FoenixRetro/f256-firmware/releases official firmware releases in this github.]

This repo is part the [https://github.com/FoenixRetro FoenixRetro] Github organisation which in turn is an attempt to gather forks of all projects which are part of the firmware and other resources relevant for the Foenix F256 new retro computers.

There are now two firmware loads available: Gen1 - for K and Jr and Gen2 - for K2 and Jr2. The only difference between these loads is the superbasic part of the firmware, in order to have a properly identified superbasic startup screen that reflects the exact computer and generation in the logo.

====== Video tutorial: ======
A timestamped part of a tutorial video covers updating the firmware as a follow up step to updating the FPGA core.

https://www.youtube.com/pOab0ocKqac?si=dzyMjtC-yjFTxbgu&t=405

==== 6809 firmware: ====
This core has specialized firmware - it is best to ask around in the appropriate channels of the [https://discord.gg/9vjUEGgcUS Foenix discord].

Firmware

2026-01-01T15:27:33Z

1BitFeverDreams:

The Foenix F256K, Jr., K2 and Jr2 computers contain 512K of flash memory which is intended to store software which should be available to the user without any media like SD-cards or IEC drives present. Think of it like a space traditionally occupied by ROM chips of 80's computers containing critical, often used programs and routines, but instead of being very rarely updated with scarce ROM chip revisions, it can be quickly updated with firmware revisions using the FoenixMgr python scripts.

This collection of software can be changed by the user by simply reprogramming the flash "ROM". At the moment (2025+) the following applications are stored in flash as a default loadout:
{| class="wikitable"
|+Collection of firmware programs as of firmware release version 2025.13
!Absolute Block* in Memory Map
!Block* Offset in onboard Flash
!Name of program
!Description
|-
|0x40
|0x00
|'''''reserved'''''
|
|-
|0x41
|0x01
|xdev
|trampoline program meant to react to developper scripts from [[FoenixMgr]]: pcopy, runpgz, runpgx
|-
|0x42 to 0x45
|0x02 to 0x05
|superbasic
|if xdev has nothing to react to, superbasic is your default startup program
|-
|0x46
|0x06
|dos
|minimalistic file management and info shell
|-
|0x47
|0x07
|'''''free'''''
|
|-
|0x48
|0x08
|fcart
|allows a user to flash the 256K Flast Cart with 8kb prepared blocks. See [[CartFlasher|this for usage]]
|-
|0x49
|0x09
|'''free'''
|
|-
|0x4A
|0x0A
|help
|text help on screen for superbasic programming
|-
|0x4B to 0x4E
|0x0B to 0x0E
|'''''free'''''
|
|-
|0x4F
|0x0F
|wget
|web get, works only for gen1 K and Jr equipped with a feather wifi board
|-
|0x50 to 0x56
|0x10 to 0x16
|fm
|f/manager - a rather feature rich file manipulation, program launcher and memory exploration software
|-
|0x57
|0x17
|'''''free'''''
|
|-
|0x58 to 0x5B
|0x18 to 0x1B
|mless
|moreorless - a text editor. See [[Moreorless|here for more information.]]
|-
|0x5D to 0x7B
|0x1D to 0x3B
|'''''free'''''
|
|-
|0x7C to 0x7F
|0x3C to 0x3F
|microkernel
|the microkernel, gadget's masterpiece used by many programs
|}
<nowiki>*</nowiki>Block: each block of flash memory is 8kb is size

To reprogram the flash, you can start with the [https://github.com/FoenixRetro/f256-firmware/releases official firmware releases in this github.]

This repo is part the [https://github.com/FoenixRetro FoenixRetro] Github organisation which in turn is an attempt to gather forks of all projects which are part of the firmware and other resources relevant for the Foenix F256 new retro computers.

There are now two firmware loads available: Gen1 - for K and Jr and Gen2 - for K2 and Jr2. The only difference between these loads is the superbasic part of the firmware, in order to have a properly identified superbasic startup screen that reflects the exact computer and generation in the logo.

Firmware

2026-01-01T15:25:59Z

1BitFeverDreams: better description of the contents and various desc improvements

The Foenix F256K, Jr., K2 and Jr2 computers contain 512K of flash memory which is intended to store software which should be available to the user without any media like SD-cards or IEC drives present. Think of it like a space traditionally occupied by ROM chips of 80's computers containing critical, often used programs and routines, but instead of being very rarely updated with scarce ROM chip revisions, it can be quickly updated with firmware revisions using the FoenixMgr python scripts.

This collection of software can be changed by the user by simply reprogramming the flash "ROM". At the moment (2025+) the following applications are stored in flash as a default loadout:
{| class="wikitable"
|+Collection of firmware programs as of firmware release version 2025.13
!Absolute Block* in Memory Map
!Block* Offset in onboard Flash
!Name of program
!Description
|-
|0x40
|0x00
|'''''reserved'''''
|
|-
|0x41
|0x01
|xdev
|trampoline program meant to react to developper scripts from [[FoenixMgr]]: pcopy, runpgz, runpgx
|-
|0x42 to 0x45
|0x02 to 0x05
|superbasic
|if xdev has nothing to react to, superbasic is your default startup program
|-
|0x46
|0x06
|dos
|minimalistic file management and info shell
|-
|0x47
|0x07
|'''''free'''''
|
|-
|0x48
|0x08
|fcart
|allows a user to flash the 256K Flast Cart with 8kb prepared blocks. See [[CartFlasher|this for usage]]
|-
|0x49
|0x09
|'''free'''
|
|-
|0x4A
|0x0A
|help
|text help on screen
|-
|0x4B to 0x4E
|0x0B to 0x0E
|'''''free'''''
|
|-
|0x4F
|0x0F
|wget
|web get, works only for gen1 K and Jr equipped with a feather wifi board
|-
|0x50 to 0x56
|0x10 to 0x16
|fm
|f/manager - a rather feature rich file manipulation, program launcher and memory exploration software
|-
|0x57
|0x17
|'''''free'''''
|
|-
|0x58 to 0x5B
|0x18 to 0x1B
|mless
|moreorless - a text editor. See [[Moreorless|here for more information.]]
|-
|0x5D to 0x7B
|0x1D to 0x3B
|'''''free'''''
|
|-
|0x7C to 0x7F
|0x3C to 0x3F
|microkernel
|the microkernel, gadget's masterpiece used by many programs
|}
<nowiki>*</nowiki>Block: each block of flash memory is 8kb is size

To reprogram the flash, you can start with the [https://github.com/FoenixRetro/f256-firmware/releases official firmware releases in this github.]

This repo is part the [https://github.com/FoenixRetro FoenixRetro] Github organisation which in turn is an attempt to gather forks of all projects which are part of the firmware and other resources relevant for the Foenix F256 new retro computers.

There are now two firmware loads available: Gen1 - for K and Jr and Gen2 - for K2 and Jr2. The only difference between these loads is the superbasic part of the firmware, in order to have a properly identified superbasic startup screen that reflects the exact computer and generation in the logo.

Software for 6502

2025-12-28T04:36:20Z

1BitFeverDreams: /* Music */ cozy midi v2.4 update

Note that when an hex address is given, it's meant to instruct as to which address to bload or to send (ie foenixmgr python script) the program (ie a .bin file) to before running it. For extra help on how to run .bin files and almost every possible scheme that has to be used to run program, you can consult this video that's also part of [[Getting Started]], this one: https://www.youtube.com/watch?v=0ShFv89KGDs

Many download links are posts in the main [https://discord.gg/9vjUEGgcUS Foenix Retro Systems discord server] which will require you to join in order to get to them.

A [[Getting Started#Demos Archive|Demo Archive]] was put together in September 2023 to get ready to show to youtubers, some of these are linked once more, in this page.

There's also the Foenix Marketplace website maintained by EMWhite with its own collection of articles and software http://apps.emwhite.org/foenixmarketplace/.

===== Curated SD card collection of games, demos, utilities =====
Here is a download link to a zip file meant to be extracted into the root of an SD card: https://github.com/Mu0n/F256MiscGoodies/tree/main/SDCard_Collection

Best to wipe out your SD card and start anew with the contents of this extracted to root. Micah's file manager doesn't like long lists of files so it really is best to not overdo it. I tried to minimize the files in root, but I couldn't for everything.

Open the readme.txt file with moreorless to see some instructions about the collection. Best to run /- fm first, then open the readme.txt from it

== Applications ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|F256-GraphicToolkit
|Sprite editor, Tilemap editor, Font editor + misc tools
|econtrerasd
|basic
|https://github.com/econtrerasd/F256-GraphicToolkit
|-
|F256 f/term
|Terminal emulator for F256K and Jr with classic (flat) memory load
|Micah
| - fterm.pgZ or use f/manager
|https://github.com/WartyMN/F256-terminal/blob/main/release/fterm.pgZ
|-
|FoenixTarot
|Tarot card readings in SuperBasic
|Mike
|basic
|https://github.com/mcassera/FoenixTarot/tree/main
|-
|Forthf256
|Forth implementation
|Vasyl
|pgz in its forth/ folder
|https://github.com/VasylTsv/ForthX16
|}

== Demos ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|badapple
|A 80x60 textmode port of Bad Apple, uses the VS1053b for quality mp3 audio. Needs a Jr2 or K2!
|Mu0n
|pgz*
|*unzip badapple.zip into the root of your SD card. If done right, the 3 files within will be in the demos/ folder. The program expects its data file there when it runs. https://github.com/Mu0n/F256MiscGoodies/blob/main/apps/badapple.zip
|-
|balls
|Draw a good quantity of multiplexed sprites, fast. Balls bouncing around
|celton
|pgz
|https://github.com/FoenixRetro/demos/blob/main/MultiplexedSprites.md
|-
|F256Archon
|Splash screen intro, plays MIDI using the SAM2695, requires a K2 or Jr2
|Mu0n
|pgz
|https://github.com/Mu0n/F256Archon/releases
|-
|f256_life
|An implementation of Conway's game of life
|mgr42
|pgz
|https://github.com/rmsk2/f256_life
|-
|F256 Mandelbrot
|Draws Mandelbrot set fast (5 mins) using coprocessor math. Allows to zoom into the set.
|mgr42
|uses basic loader
|https://github.com/rmsk2/F256_Mandelbrot
|-
|F256ShowCase
|Shows sliding tiling graphics, moves with joystick
|eriktier
|$0000
|https://github.com/pig-games/F256Showcase
|-
|fnxmas23
|PSG mod music, scrolling text, sound effects, must see demo!
|dwsJason and digarok
|pgz
|https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/apps/xmas24_k2.pgz revised version that can run on wave 2 Jr2 and K2 as well
|-
|foenixmas23
|Xmas 2023 demo with SID music from the classic 1983 C64 xmas demo
|EMWhite
|uses basic loader
|http://apps.emwhite.org/shared-files/815/?foenixmas23.zip
|-
|livingworlds
|Living Worlds, a port of a color cycling by Mark Ferrari, ported here on the F256 by haydenkale
|haydenkale
|$0000
|https://github.com/clandrew/livingworlds/tree/e4532e0d530b76ccb90368fdf5ad10bfa2deeb12
|-
|mandel
|Will draw a mandelbrot set in 3 hours, more useful as a stability test than a useful fractal program
|Mu0n
|basic
|https://github.com/Mu0n/F256KbasicBASICdoodles?tab=readme-ov-file#fractal
|-
|wormhole
|Shows a fast wireframe animation of a wormhole
|haydenkale
|pgz or bin at $0000
|https://github.com/clandrew/wormhole?tab=readme-ov-file
|}

== Games ==

{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|bbombers
|Boulder Bombers (Alpha-2) Clone of Canyon Bombers
|Scott (xDraconian)
|pgx
atari joystick
|https://github.com/scttgs0/BoulderBombers<nowiki/>https://github.com/scttgs0/BoulderBombers/releases/tag/alpha_2
|-
|Bombsweeper
|Bomb sweeper port
|beethead
|pgz
|https://discord.com/channels/691915291721990194/855689509520932885/1196352934083035156
|-
|Cosmic
|Shoot 'em up
|beethead
|pgz
|https://discordapp.com/channels/691915291721990194/1054250238308790342/1175982979537969214
|-
|F256-Trek
|Updated Trek, with modern F256 Graphics
|econtrerasd
|basic
|[https://github.com/econtrerasd/Trek-F256/releases/tag/v1.0 https://github.com/econtrerasd/Trek-F256/releases]
|-
|F256 two to the power of eleven
|Port of the puzzle game of 2048
|mgr42
|pgz
|https://github.com/rmsk2/F256_2048<nowiki/>
|-
|fillerup
|Fill 'er Up (WIP)
Qix-like game
|Scott (xDraconian)
|pgx
atari joystick
|https://github.com/scttgs0/Fill-er-up
|-
|FusionDrive
|An outrun type game that also plays a MIDI soundtrack
|Mu0n
|pgz
|wip v0.2, can use a NES pad #1 to move around, or left/right arrow keys currently https://github.com/Mu0n/F256KsimpleCdoodles/tree/main/NoFussDemos
|-
|jewelkeeper
|Sokoban port
|beethead
|pgz
|https://github.com/Mu0n/F256MiscGoodies/raw/refs/heads/main/apps/jewelkeeper.pgz<nowiki/>You can now specify a level file when loading the game <code>/- jewelkeeper.pgz <levels.txt></code>. Find more levels at https://www.sourcecode.se/sokoban/levels.php. Keep in mind the maximum level dimension is 20x15, anything larger will be ignored
|-
|Jr Wördl
|port of Wordle
|AgeAgeEye
|basic
|https://github.com/ageageeye/Superbasic-F256Jr-examples
|-
|kartdemo
|Kart racing game
|SprySloth
|pgz
|https://discord.com/channels/691915291721990194/1225217654487253094/1228246780840513556
|-
|Lair of the Lich King
|Rogue like dungeon crawler. Demo has 3 levels; full has 25+
|Micah
| - lkdemo/lk.pgz
|[https://discord.com/channels/691915291721990194/1230670413361844244/1317256215566487593 1.0 Beta 19 Demo]
|-
|livewire
|Livewire (WIP)
Tempest-like game
|Scott (xDraconian)
|pgx
atari joystick
|https://github.com/scttgs0/Livewire
|-
|Maze-Munch
|Pac-Man clone
|SprySloth
|pgz
|https://github.com/cmassat/Maze-Munch
|-
|pdefense
|Planetary Defense (WIP)
|Scott (xDraconian)
|pgx
mouse
atari joystick
|https://github.com/scttgs0/PlanetaryDefense
|-
|Shanghai/Mahjongg
|A clone of Shanghai. Also known as Mahjongg
|mgr42
|pgz or KUP
mouse needed
|https://github.com/rmsk2/f256_mahjong
|-
|Ski-Jr
|Ski game downhill
|digarok
|basic
|https://github.com/digarok/superbasic-traveler/blob/main/ski-jr.bas
|-
|Track & Field
|Olympic Game by Konami (WIP)
|Scott (xDraconian)
|pgz
atari joystick or keyboard
|
|-
|Tetris
|Good old 80's game
|Daniel Tremblay (Grenouye)
|pgz
atari joystick or keyboard
|https://github.com/dtremblay/c256-tetris/tree/f256k
|}

== Game Jam #01 - April 6th/7th 2024 ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|15puzzle
|Number sort puzzle
|mgr42
|pgz
|https://github.com/rmsk2/f256_15puzzle/releases<nowiki/>
|-
|Flight Simulator
|flying simulator
|sduensin
|pgz
|https://cdn.discordapp.com/attachments/1225481966200029286/1227764847819620454/shotel.pgz
|-
|frisbee
|Frisbee throw past sport game
|dwsJason
|pgz
|https://github.com/dwsJason/f256/blob/develop/merlin32/frisbee/frisbee.pgz
|-
|Impasse
|Shoot 'em up
|digarok
|pgz
|https://discord.com/channels/691915291721990194/1225481966200029286/1227075699895046235
|-
|soccur
|mutliplayer game of soccer
|beethead
|pgz
|executable:https://discord.com/channels/691915291721990194/1225481966200029286/1226808228948611184
source code:
https://discord.com/channels/691915291721990194/1225481966200029286/1226812472069980232
|-
|Trek
|port of classic Star Trek game
|contrerasd
|basic
|https://discord.com/channels/691915291721990194/1225481966200029286/1226727849944289341
|-
|Typing Star
|typing reaction game
|haydenkale
|pgz
|https://github.com/clandrew/typestar
|-
|}

== Game Jam #02 - October 25th-November 1st 2024 ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|Bach's MIDI Hero
|Free MIDI/PSG play + note play tutorial
|Mu0n
|pgz
the MIDI feature requires a F256K2 or F256Jr2; a legacy PSG option also allows F256K and F256Jr to still hear it. Optionally uses a MIDI in controller plugged in.
|https://github.com/Mu0n/F256KsimpleCdoodles/releases/download/v1.2/BachHero.pgz
|-
|f256_snake
|
|mgr42
|pgz. Use cursor keys, Atari joystick or SNES pad to play
|https://github.com/rmsk2/f256_snake
|-
|fnxsnake
|
|silk-neon
|pgz
|https://github.com/ksiondag/fnxsnake
|-
|The Hallow
|
|beethead
|pgz
|https://github.com/noyen1973/FoenixGameJamOct2024
|-
|Halloween Birthday
|
|SprySloth
|pgz
|https://github.com/cmassat/GameJam2024_F256K
|-
|Haunted Mansion
|
|digarok
|superbasic
|https://github.com/digarok/fnxgamejam-haunted-mansion
|-
|Kooyan
|
|Grenouye
|pgz
|https://github.com/dtremblay/kooyan.git
|-
|Spooky Run
|
|dwsJason
|pgz
|https://github.com/dwsJason/spooky
|-
|Trick or Treat
|
|Mike
|pgz
|https://github.com/mcassera/TrickOrTreat
|-
|Ultima III - Exodus
|port
|Minstrel Dragon
|pgz
|https://github.com/minstreldragon/F256_Ultima_3
|-
|Warlock
|remake of 68000 game
|xDraconian
|pgz
atari joystick
DOWN=change_level
UP=jump
UP-LEFT=leap
UP-RIGHT=leap
|https://github.com/scttgs0/Foenix_GameJam_Oct2024
|}

== Game Jam #03 - April 18th-April 27th 2025 ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|Arcade Shanghai v1.2
|Shanghai clone
|contrerasd
|basic, keep the .bas program in root, the rest in the provided ashanghai/ folder
|https://github.com/econtrerasd/ashanghai/releases
|-
|Bawk Bawk Cluck Cluck
|Chicken themed platformer
|beethead
|pgz
|https://github.com/noyen1973/FoenixGameJamApr2025
|-
|BitLadder
|Shoot 'Em Up
|Mu0n
|pgz. For full sound compatibility, a Jr2 or K2 is needed.
Uses 4 sound chips! (PSG, SID, OPL3, MIDI)
|https://mu0n.itch.io/bitladder
|-
|F256_Commando
|Commando port
|SprySloth
|pgz
|https://github.com/cmassat/F256_Commando
|-
|F256_LodeRunner
|Lode Runner port
|Minstrel Dragon
|pgz
|https://github.com/minstreldragon/F256_Loderunner/releases
|-
|Mahjong
|Shangai clone
|mgr42
|pgz
|https://github.com/rmsk2/f256_mahjong/releases
|-
|Quarth
|Block placement arcade game
|Grenouye
|pgz
|https://grenouye.itch.io/f256-quarth
|-
|Skee(ster)-Ball
|
|Mike
|pgz
|https://github.com/mcassera/skeeball256/tree/main
|}

== Music ==

{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|cozyMIDI
|Plays a SMF with the SAM2695 or VS1053b
|Mu0n
|pgz
|cozyMIDI v2.4 can open and play type 0 and type 1 standard MIDI files (SMF)
needs a Jr2 or K2
with a 2x core at https://github.com/Mu0n/F256KsimpleCdoodles/tree/main/NoFussDemos

run operation 1: just as itself, it will force you to pick a midi file in the 'midi/' folder /- cozymidi

run operation 2: in f/manager, if you put this as <code>midiplayer.pgz</code>in the '_apps/' folder, f/manager will open midi file with it when you launch .mid files.

Program link: https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/cozymidi.pgz
|-
|digestMidi
|converts .mid to .dim
|Mu0n
|pgz
|.mid files are slow to load, parse and prepare for a playback. This tool comes in to convert them into a .dim format that strips out unnecessary MIDI commands and sets it up for timer0 time delays. Works with type 0 and type 1 standard midi files. This tools does the conversion and lets you hear the result.
Find the latest version here: https://github.com/Mu0n/F256MiscGoodies/tree/main/apps
|-
|EdInHisLib
|SID+OPL3 simultaneously
|beethead, ported from xantax
|pgz
|F256 port: https://discordapp.com/channels/691915291721990194/1054249926521016392/1184413356598231120
original: <nowiki>https://csdb.dk/release/?id=170898</nowiki>. Not 100% accurate but close.
|-
|F256amp
|mp3, ogg, wav, wma file playback
|Mu0n
|pgz
|(aka audioplayer.pgz) v2.3 Needs a Jr.2 or K2 since it uses the VS1053b chip.
For a starter collection of .mp3 and other audio files, check the SD curated collection here: https://github.com/Mu0n/F256MiscGoodies/tree/main/SDCard_Collection
run operation 1: just as itself, it will force you to pick an audio file. it expects a <code>media/mp3/</code> folder, but it can live without it and peek into the root instead.

run operation 2: with an argument, it will auto-play it: /- f256amp yourmp3file.mp3

run operation 3: in f/manager, if you put this as <code>audioplayer.pgz</code> in the '_apps/' folder. This lets f/manager automatically open up .mp3, .wav, .ogg, .wma that you press enter on.

Program link: https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/f256amp.pgz
|-
|FireJam
|all chips, music playing with MIDI in
|Mu0n
|pgz
|v1.2 MIDI in and out capable, it will still partially work with a Jr. (PSG, and SID if you have them), a K (PSG, SID, OPL3) and the newest wave 2 Jr2 and K2 (PSG, SID, OPL3, SAM, VS1053b).
Best to use with a MIDI in controller, but it'll be controllable with arrows and space to make notes individually, or the F keys to start beats. https://github.com/Mu0n/F256KsimpleCdoodles/tree/main/NoFussDemos
|-
|jrtracker
|Tracker based in basic and uses the PSG
(considered obsolete, use tracker2)
|contrerasd
|basic
|https://ptb.discord.com/channels/691915291721990194/1008139105386889346/1188292876984143983
|-
|modo
|MOD player using the PSG
|dwsJason and digarok
|pgz
|https://discordapp.com/channels/691915291721990194/855689509520932885/1190723114661859429
|-
|Musik
|Music piece demo using MIDI
|Mike
|pgz
|https://github.com/mcassera/Musik/blob/main/Musik.PGZ<nowiki/>Musikalisches Würfelspiel
Requires a Jr2 or K2 since it uses MIDI
|-
|opl3snooper
|playback of VGM files (that use opl2 and opl3) and MIDI in
|Mu0n
|pgz
|v1.0 mainly plays back vgm files, but you can pause it and snoop around the channel instruments and play up to 18 note polyphony with MIDI in. expects a collection in media/vgm/, or it will browse from the root if it can't find.
It can load a .spl (Simple PLaylist) text file, which is one file per line, including their respective paths.
Requires a Jr2 or K2 with a 2x core to use the extra bank of SRAM.
For a starter collection of .vgm files, check the SD curated collection here: https://github.com/Mu0n/F256MiscGoodies/tree/main/SDCard_Collection
run operation 1: just as itself, it will force you to pick a midi file in the 'media/vgm/' folder

run operation 2: in f/manager (v1.1b9 and up), if you put this as <code>vgmplayer.pgz</code>in the '_apps/' folder, f/manager will open midi file with it when you launch .vgm files.

Program link: https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/opl3snooper.pgz
|-
|opl3tweak
|uses MIDI in, plays 18 channels polyphony in real time to the YMF262 OPL3. Fish for random register values.
|Mu0n
|pgz
|v0.1. Can't save or load instrument definitions yet. Needs a K2 with a MIDI in currently. https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/opl3tweak.pgz
Arrows to move around, + and - keys to incr/decr values or type in a hex value directly under the highlighted position.
|-
|piano
|Plays some PSG notes with the keyboard
|Mu0n
|basic
|https://github.com/Mu0n/F256KbasicBASICdoodles?tab=readme-ov-file#pulse-sound-generator-piano
|-
|playvgm
|plays a headless vgm file with OPL3
|G33kyAndIKnowIt
|pgx
|https://github.com/natebarney/playvgm-f256k
some example music files can be gotten from this post:
[https://discord.com/channels/691915291721990194/975117322836656138/1220366429640065074 https://discord.com/channels/6][https://discord.com/channels/691915291721990194/975117322836656138/1220366429640065074 91915291721990194/975117322836656138/1220366429640065074]

1) open a normal .vgm into a hex editor <nowiki/>and cut out the header bytes from 0x00 to 0x<nowiki/>FF

2) run by first using superbasic's '''''bload''''' '''''"yourmusicfile", $01000'''''
followed by running this program with '''''/- playvgm.pgx'''''
|-
|sidtweak
|uses MIDI in, plays 6 channels polyphony in real time to the dual SID. Fish for random register values.
|Mu0n
|pgz
|v0.1. Can't save or load instrument definitions yet. Needs a K2 with a MIDI in currently. https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/sidtweak.pgz
Arrows to move around, + and - keys to incr/decr values or type in a hex value directly under the highlighted position.
|-
|rawsidplayer
|plays raw PSID files from the HVSC collection, converted by zigreSID
|Mu0n
|pgz
|(formely psidplayer) v0.2 find rawsidplayer.pgz and a starter .rsd file (raw sid dumps). For a starter collection of .rsd files, check the SD curated collection here: https://github.com/Mu0n/F256MiscGoodies/tree/main/SDCard_Collection
extract sid.zip into a folder /sid/ in the root of your SD card, that's where psidplayer.pgz will first look to let you pick a file. failing that, it will fall back to the root folder and let you navigate.

program link:

https://github.com/Mu0n/F256KsimpleCdoodles/raw/refs/heads/main/NoFussDemos/rawsidplayer.pgz
|-
|tracker2 v1.5
|Like jrtracker.bas, but using both PSGs
|contrerasd
|basic
|https://github.com/econtrerasd/Tracker2/releases
|}

== Uti<nowiki/>lities ==

{| class="wikitable"
|+
!Program
!Descrip<nowiki/>tion
!Author
!Notes on running
!Link
|-
|basic2text
|A simple utility for translating Commodore BASIC (all variants) from its native tokenized file format to a text format that can be opened with SuperBASIC. Does not perform any code translation: all adaptation is up to you.
|Micah
|pgZ
|https://github.com/WartyMN/F256-BasText/releases/latest
|
|-
|dcopy
|A tool to copy files from one drive to another or to/from your PC via RS-232 and a nullmodem cable
|mgr42
|pgz/flash
|https://github.com/rmsk2/f256_dcopy
|
|-
|f/manager
|A general file utility, launcher, and memory viewing program. Dual-panel file/memory browsers; copy between disks, between folders on same disk, and from memory to disk and vice versa; delete, rename, and duplicate files; view files as hex or text (with word-wrap); launch applications and known file types; set the RTC clock; search in RAM and flash. Works with internal SD card and IEC devices such as FNX1591 and Commodore 1541. Can be installed in primary flash position ahead of SuperBASIC or DOS, or at a higher location. Can also be run from disk with "- fm.pgz".
|Micah
|pgZ/flash
|https://github.com/WartyMN/F256-FileManager/releases
|
|-
|f256_reset
|A small utility that lets you reset the machine through this piece of flash software
|mgr42
|flash
|https://github.com/rmsk2/f256_reset
|
|-
|fcart
|A program that allows to write data to flash expansion cartridges
|mgr42
|pgz, on-board and cartridge flash
|https://github.com/rmsk2/cartflash
|
|-
|flashcart
|Allows to wipe a block of flash or write a program to a flash cart, from this basic program from the F256Jr/K
|redfool.
|basic
|https://github.com/Red-Fool/F256_FlashCart/tree/main
|
|-
|flashselect
|Allows to select a program to start from a flash cartridge via a menu
|mgr42
|pgz, on-board and cartridge flash
|https://github.com/rmsk2/flashselect
|
|-
|fonts
|A variety of fonts using the standard F256 character set arrangement. Load with the F256 file manager (f/manager), or your own code.
|Micah
|(not a program)
|[https://github.com/WartyMN/Foenix-Fonts/tree/main https://github.com/WartyMN/Foenix-Fonts]
|
|-
|midiStuff
|Test program for a F256K2 or F256Jr2 that sends MIDI data to the internal sam2695 dream chip that produces MIDI based audio. Also test a keyboard controller plugged in the MIDI in port.
|Mu0n
|pgz
|https://github.com/Mu0n/F256KsimpleCdoodles/blob/main/README.md#midistuff
|
|-
|moreorless
|A text editor for the Foenix 256 line of computers
|mgr42
|pgz
|https://github.com/rmsk2/moreorless/releases/
|
|-
|pgz2flash
|A program for your Linux, Windows or MacOS machine to turn any PGZ or SuperBASIC program into a KUP which can be run from cartridge or onboard flash memory
|mgr42
|Executable for modern computers
|https://github.com/rmsk2/pgz2flash
|
|-
|sidTester
|Simple superbasic program that tests out all 3 voices of the SID1 on the Jr (if populated), K, Jr2 and K2. Ported by Mu0n, made by andy on HackJunk.com https://hackjunk.com/2017/11/07/commodore-64-sid-tester/
|andy
|basic
|https://github.com/Mu0n/F256MiscGoodies/blob/main/apps/sidtester.bas
|
|-
|testsuite.bas
|a series of tests for your F256, video modes and sound chips
|econtrerasd
|basic
|run from the root, https://raw.githubusercontent.com/Mu0n/F256MiscGoodies/refs/heads/main/apps/testsuite.bas
|
|-
|wget<nowiki/>
|<nowiki/>fetches a file from a http address if you have a network connection active. Works with the K and Jr. ESP32 Feather 'huzzah' board. Not meant to be used with the K2 and Jr2 Wiznet chip.
|gadget
|<nowiki/>pgz/flash
|https://github.com/ghackwrench/F256_wget
|
|}

== Sample Code ==

{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|Assembly examples
|Sample programs for several features of the Foenix F256K and Jr.
|mgr42
|read github
|https://github.com/rmsk2/Hello_Foenix256_Jr/blob/main/testprogs.md
|-
|cc65 example
|c example code
|gadget
|read github
|https://github.com/ghackwrench/F256_Jr_Kernel_DOS
|-
|digarok basic stuff
|Lots of basic examples
|digarok
|read github
|https://github.com/digarok/superbasic-traveler/tree/main
|-
|Mu0n's F256K asm doodles
|Some asm examples
|Mu0n
|read github
|https://github.com/Mu0n/F256KsimpleASMdoodles
|-
|Mu0n's F256K basic doodles
|Some basic examples
|Mu0n
|read github
|https://github.com/Mu0n/F256KbasicBASICdoodles
|-
|Mu0n's F256K C doodles
|Some C examples
|Mu0n
|read github
|https://github.com/Mu0n/F256KsimpleCdoodles
|-
|Raúl SQ basic repo
|F256 SuperBASIC Trigonometry
|Raúl SQ
|basic
|https://github.com/raul-sq/FoenixF256K2
|-
|tcp example
|connects to a server and gets typed in text echoed back to you
|gadget
|$2000
|https://github.com/ghackwrench/F256_example_tcp
|}