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

FPGA Releases

2026-03-26T21:41:10Z

Grenouye: Correct the publication date of the F256Jr2 65816 Ext Core.

# 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-2024]
|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

Emulation

2026-03-26T21:21:42Z

Grenouye: Updated the Discord link for #emulation-mame.

== FoenixIDE ==
The FoenixIDE provides emulation of various Foenix Retro Systems including,
{| class="wikitable"
|+
!System
!Descripton
|-
|F256K(816)
|The F256K computer with integrated keyboard and WDC65C816 processor.
|-
|F256K
|The F256K computer with integrated keyboard and WDC65C02 processor.
|-
|Jr(816)
|The F256 Jr. computer with a WDC65C816 processor.
|-
|Jr
|The F256 Jr. computer with a WDC65C02 processor.
|-
|U+
|The C256 Foenix U+ (4Meg RAM Config) - Legacy
|-
|U
|The C256 Foenix U (2Meg RAM Config) - Legacy
|-
|C
|The C256 Foenix FMX - Legacy
|-
|B
|The C256 Foenix (original) - Legacy
|}

=== Installation ===
The current Windows installation file (FoenixIDE.Setup.msi) and source code can be found here,
'''https://github.com/Trinity-11/FoenixIDE/releases'''

== Foenijs ==
Runs in your browser with no setup.

https://www.white-flame.com/foenijs/, Wiki page [[Foenijs]]

* Supports the F256 line (Jr, Jr2, K, K2), with 65c02 and 65816
* All graphics modes & features
* All audio chips (still some rough edges)
* PS/2 mouse, PS/2 keyboard, and built-in K keyboard emulation
* NES/SNES via USB gamepads, Atari joystick via keyboard.
* SD Card images are persistently stored in your browser's IndexedDB
** Card library, with full card image upload/download, and new formatted image creation
** Individual file transfers directly to/from card images
** 1-click program launch
* Strong CPU, stack, and device debugging support, with live views for memory and individual graphics data.
* Directly run a program or mount a card by adding URL parameters
** <code>url=http://...</code> to a <code>pgz</code>/<code>pgx</code>/<code>bas</code> program, or <code>bin</code>/<code>iso</code>/<code>img</code> card image with optional <code>.gz</code> or <code>.zip</code>.
*** Github links automatically rewrite to their <code>raw.githubusercontent.com</code> form to get around CORS issues.
** <code>run=filename</code> to autorun a file within a card image URL
** <code>model=f256jr</code>, <code>f256jr2</code>, <code>f256k</code>, or <code>f256k2</code>
** Formatted as e.g. <code><nowiki>https://www.white-flame.com/foenijs/?url=...&model=</nowiki>...</code>

TODO:

* Core2x and 6809
* Better Atari joystick support
* Networking
* K2 optical keyboard
* Cartridges
* Hardware I/O ports: debug ports, IEC port, DIP switches, MIDI ports

[https://discord.com/channels/691915291721990194/1455809214231478414 Discord support channel] on the Wildbits server, with the author wf2. Feature requests are welcomed.

== MAME ==
This emulator is currently under development (23 Mar 2025). See here: https://github.com/dtremblay/mame

Releases are published in GitHub and announced in Discord: https://discord.com/channels/691915291721990194/1439341743785906249 named '''#emulation-mame'''.

(a work-in-progress sdcard .img file containing many games, tools and media files prepared in March 2025 can be found here: https://github.com/Mu0n/F256MiscGoodies/tree/main/SDCard_Collection consult the readme of that page to get the right file)

MAME is available for Linux, Mac and Windows. Future development of the F256 machines will support the 65816, 6809 and 68000 processors.

Currently, only the F256K is partially implemented.

* Memory Management Unit (MMU) at address $0
* SD Card with SPI
* Matrix Keyboard with VIA
* Game Controllers: Atari Joysticks with VIA
* Text display, Sprites, Tiles and Bitmaps (respecting the layers)
* Interrupts: SOF, SOL, RTC, Timers, VIA0, VIA1
* Timers: Real-Time Clock (RTC), Timer0 (at 25Mhz) and Timer1 (at SOF 60 or 70Hz)
* Math processor
* Random Number Generator (RNG)
* Sound Chips: PSG (dual - stereo), OPL, SID (dual - stereo)
* Direct Memory Access (DMA)
Unimplemented features:

* UART (serial port)
* IEC
* CODEC
* NES/SNES Game Controllers
* PS/2 Mouse and Keyboard
* WIFI
* Buzzer and status LEDs
* Debug port
* DIP switches
* External Memory Cartridge

====== How to Run MAME ======
MAME has quite an extensive list of features that can be enabled and disabled.

To run F256K in full screen mode:

<code>./f256 f256k</code>

To run in window mode:

<code>./f256 f256k -window -resolution 800x600</code>

To set a disk image (for the SD Card):

<code>./f256 f256k -harddisk sdcard.img</code>

To disable sound:

<code>./f256 f256k -sound none</code>

To collect logs:

<code>./f256 f256k -log</code>

Within MAME emulator, you can see the frame rate (in percent) by pressing the '''F11''' key.

You can modify settings and key assignments using the '''TAB''' key.

You can see the debug console (to step in CPU memory and view memory values) using the back-tick key '''`'''.

Exit the emulator using the '''ESC''' key.

'''''Note''': all these keys can be modified, so these are the default settings.''

====== Creating an SD Card Image to use in MAME Emulator and Foenix IDE ======
'''Easy Method:'''

You can use the FoenixIDE to write your SD Card to a single ISO file. In the FoenixIDE menu, select '''Tools | Export SD Card to IMG.''' You will then get a Save dialog: pick a filename to save.

'''Hard Method:'''

''These instructions require a Linux Operating System or MinGW.''

Create a blank image of 64 blocks of 1 MB:

<code>dd if=/dev/zero of=sdcard.img bs=1M count=64</code>

Partition the image:

<code>parted sdcard.img --script mklabel msdos</code>

<code>parted sdcard.img --script mkpart primary fat32 1MiB 100%</code>

You need to know the starting sector for the next step. To find the '''starting''' '''sector''': <code>fdisk -l sdcard.img</code>

You'll get something like this:

<code>Device Boot Start End Sectors Size Id Type</code>

<code>sdcard.img1 2048 131071 129024 63M c W95 FAT32 (LBA)</code>

The '''starting sector''' is "2048" in the listing above.

Create a Loop Device for Formatting

Map the partition to a loop device:

<code>sudo losetup -o $((2048 * 512)) --sizelimit $((129024 * 512)) /dev/loop0 sdcard.img</code>

Format it: <code>sudo mkfs.vfat -F 32 /dev/loop0</code>

Detach it: <code>sudo losetup -d /dev/loop0</code>

The disk image is now ready, but it's empty. To copy files into the disk, you need to mount it. After it's mounted, you can copy files to it.

<code>mkdir /mnt/f256</code>

<code>sudo mount -o loop,offset=$((2048 * 512)) sdcard.img /mnt/f256</code>

<code>cp myfile.txt mnt/</code>

<code>sudo umount mnt</code>

Firmware

2025-12-31T11:34:12Z

Grenouye: Explaining the difference between Gen1 and Gen2 firmware.

The Foenix F256K and Jr.computers contain 512K of flash ROM which is intended to store software which should be available to the user without any media like SD-cards or IEC drives present. This collection of software can be changed by the user by simply reprogramming the flash ROM. At the moment the following applications are stored in flash as a default

* The Kernel
* SuperBASIC
* pexec, a tool to start executables in various formats
* wget, a tool to download data from webservers (if you have TCP networking enabled)
* An online help system for SuperBASIC
* A file manager
* A simple command shell

and therefore make up the firmware of the Foenix computers.The current version of the F256K and F256Jr. firmware can be downloaded [https://github.com/FoenixRetro/f256-firmware/releases here].

The link leads to the release page of the [https://github.com/FoenixRetro/f256-firmware Github repo] which is used to prepare the firmware packages. 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.

FPGA Upgrade Guide (F256JrJr)

2025-12-30T14:15:40Z

Grenouye: /* Install Vivado Lab Soltions - 2023.2 */ Fixed a minor typo.

Upgrading the FPGA on F256JrJr can be done using the built-in USB Type-C port. Plug JrJr into your computer and turn it on, then follow the steps below that are specific to your operating system.

== Linux and macOS ==

'''macOS Note:''' The default USB serial driver on macOS has issues sometimes with the chip used on JrJr. If you encounter any issues upgrading the FPGA firmware, you can try using FTDI's driver, available here: [https://ftdichip.com/drivers/vcp-drivers]

=== Using openFPGALoader ===
[https://github.com/trabucayre/openFPGALoader '''openFPGALoader'''] is the easiest way to upgrade the firmware on JrJr. The following steps explain how to upgrade the FPGA firmware on JrJr using openFPGALoader.
# Install openFPGALoader
#: The <code>openfpgaloader</code> package is available on several of the most common Linux distros (including Ubuntu, Arch, and Fedora) and is also available on Homebrew for macOS.
#: If you can't install it through your package manager, other options for installing openFPGALoader can be found here: [https://trabucayre.github.io/openFPGALoader/guide/install.html]
# Run openFPGALoader
#: The following command will upgrade the firmware. Replace <code><firmware></code> with the path to the FPGA firmware file you downloaded.
#: <code>openFPGALoader -c ft4232 --fpga-part xc7a35tcsg324 -f <firmware></code>

== Windows ==

In Windows you don't need to install any drivers to communicate with the JrJr, but you'll need to install some software first

=== Install Vivado Lab Solutions - 2023.2 ===
Please use the following link to download Vivaldo Lab Solutions:

https://www.xilinx.com/member/forms/download/xef.html?filename=Vivado_Lab_Win_2023.2_1013_2256.tar.gz

Make sure you select the recommended version 2023.2, please note that you might need to sign up to AMD's development tools before you download the tool. Don't worry it's free and after signing up and confirming your email you can download the software.

It is recomended that you have your F256 JrJr disconnected from the computer while you install the software.

After the software is installed, you should be able to see additional COM ports in Device Manager.

=== Program the FPGA from Vivaldo Lab Solutions ===
* When you enter "Vivado Lab" make sure you click on The Option "Open Hardware Manager", this will open a new window.
* On the new window at the very Top you will see a message "No hardware target is open"
* Proceed to connect you F256 JrJr to your computer with an USB to USB3 cable and turn it on, your PC's USB port should provide enough power to turn on your JrJr and also use the USB cable to program it
* Click on the "Open Target" link, shown in the message at the top, and select "Auto Connect" from the options shown
* It will try to connect for a few seconds and it will add the device "xc7a35t_0" to the list of devices
* Click this device name with the mouse alternate button to open a context menu
* Select the option "Add Configuration Memory Device"
* A dialog will open with a lot of information, go to the "Select Configuration memory Part" and in the Search box type mt25ql128-spi-x1_x2_x4 to select the memory chip used in the JrJr
* CLick on the device name filtered from the list and press "OK"
* It will ask you if you want to program the device now, you can press Ok to get to the programming right away
* If for any reason you decided to not the program it yet, you can program it by clicking with the alternate mouse button in the "mt25ql128-spi-x1_x2_x4" device added in the tree list, and selecting from the context menu the option "Program Configuration Memory Device..."
* A new dialog will appear and you need to select the configuration file, these are the .mcs files published in the f256jr2x-fpga-release section in discord (check link below)
https://discord.com/channels/691915291721990194/1319458207743082627
* Select the desired .mcs file from your file system and press OK
* Keep the "Program Operations" options as are provided by default and press the "OK" button
* The device will be erased and programmed, this will take about 1 minute
* A message "Flash programming completed succesfully" will be shown after the device is succesfully finished it's programming.
 Congratulations!, your FPGA should be updated now!, you can turn off your "F256 JrJr" and disconnect it from the USB port

Emulation

2025-10-22T20:00:29Z

Grenouye: /* Creating an SD Card Image to use in MAME Emulator and Foenix IDE */

== FoenixIDE ==
The FoenixIDE provides emulation of various Foenix Retro Systems including,
{| class="wikitable"
|+
!System
!Descripton
|-
|F256K(816)
|The F256K computer with integrated keyboard and WDC65C816 processor.
|-
|F256K
|The F256K computer with integrated keyboard and WDC65C02 processor.
|-
|Jr(816)
|The F256 Jr. computer with a WDC65C816 processor.
|-
|Jr
|The F256 Jr. computer with a WDC65C02 processor.
|-
|U+
|The C256 Foenix U+ (4Meg RAM Config) - Legacy
|-
|U
|The C256 Foenix U (2Meg RAM Config) - Legacy
|-
|C
|The C256 Foenix FMX - Legacy
|-
|B
|The C256 Foenix (original) - Legacy
|}

=== Installation ===
The current Windows installation file (FoenixIDE.Setup.msi) and source code can be found here,
'''https://github.com/Trinity-11/FoenixIDE/releases'''

== Foenijs ==
https://www.white-flame.com/foenijs/

A web-based emulator in development for the F256Jr and F256K, with 65c02. Gen2, Core2x and 65816 are in progress.

Most of the primary functions work, including all text & graphics modes with raster effects, SD Card images, USB gamepads, and PSG square wave sound. SuperBASIC runs well, but a number of .pgz programs don't quite work fully yet.

Upload/download individual files, as well as SD Card images. The emulated storage is permanently stored in your browser's IndexedDB.

A standout feature is the CPU and stack debugging support.

If your program doesn't run correctly on here, and you'd like to help from the asm side of things, contact user wf2 on the Foenix Discord.

== MAME ==
This emulator is currently under development (23 Mar 2025). See here: https://github.com/dtremblay/mame

Releases are published in GitHub and announced in Discord: https://discord.com/channels/691915291721990194/1330998392481906768

(a work-in-progress sdcard .img file containing many games, tools and media files prepared in March 2025 can be found here: https://github.com/Mu0n/F256MiscGoodies/tree/main/SDCard_Collection consult the readme of that page to get the right file)

MAME is available for Linux, Mac and Windows. Future development of the F256 machines will support the 65816, 6809 and 68000 processors.

Currently, only the F256K is partially implemented.

* Memory Management Unit (MMU) at address $0
* SD Card with SPI
* Matrix Keyboard with VIA
* Game Controllers: Atari Joysticks with VIA
* Text display, Sprites, Tiles and Bitmaps (respecting the layers)
* Interrupts: SOF, SOL, RTC, Timers, VIA0, VIA1
* Timers: Real-Time Clock (RTC), Timer0 (at 25Mhz) and Timer1 (at SOF 60 or 70Hz)
* Math processor
* Random Number Generator (RNG)
* Sound Chips: PSG (dual - stereo), OPL, SID (dual - stereo)
* Direct Memory Access (DMA)
Unimplemented features:

* UART (serial port)
* IEC
* CODEC
* NES/SNES Game Controllers
* PS/2 Mouse and Keyboard
* WIFI
* Buzzer and status LEDs
* Debug port
* DIP switches
* External Memory Cartridge

====== How to Run MAME ======
MAME has quite an extensive list of features that can be enabled and disabled.

To run F256K in full screen mode:

<code>./f256 f256k</code>

To run in window mode:

<code>./f256 f256k -window -resolution 800x600</code>

To set a disk image (for the SD Card):

<code>./f256 f256k -harddisk sdcard.img</code>

To disable sound:

<code>./f256 f256k -sound none</code>

To collect logs:

<code>./f256 f256k -log</code>

Within MAME emulator, you can see the frame rate (in percent) by pressing the '''F11''' key.

You can modify settings and key assignments using the '''TAB''' key.

You can see the debug console (to step in CPU memory and view memory values) using the back-tick key '''`'''.

Exit the emulator using the '''ESC''' key.

'''''Note''': all these keys can be modified, so these are the default settings.''

====== Creating an SD Card Image to use in MAME Emulator and Foenix IDE ======
'''Easy Method:'''

You can use the FoenixIDE to write your SD Card to a single ISO file. In the FoenixIDE menu, select '''Tools | Export SD Card to IMG.''' You will then get a Save dialog: pick a filename to save.

'''Hard Method:'''

''These instructions require a Linux Operating System or MinGW.''

Create a blank image of 64 blocks of 1 MB:

<code>dd if=/dev/zero of=sdcard.img bs=1M count=64</code>

Partition the image:

<code>parted sdcard.img --script mklabel msdos</code>

<code>parted sdcard.img --script mkpart primary fat32 1MiB 100%</code>

You need to know the starting sector for the next step. To find the '''starting''' '''sector''': <code>fdisk -l sdcard.img</code>

You'll get something like this:

<code>Device Boot Start End Sectors Size Id Type</code>

<code>sdcard.img1 2048 131071 129024 63M c W95 FAT32 (LBA)</code>

The '''starting sector''' is "2048" in the listing above.

Create a Loop Device for Formatting

Map the partition to a loop device:

<code>sudo losetup -o $((2048 * 512)) --sizelimit $((129024 * 512)) /dev/loop0 sdcard.img</code>

Format it: <code>sudo mkfs.vfat -F 32 /dev/loop0</code>

Detach it: <code>sudo losetup -d /dev/loop0</code>

The disk image is now ready, but it's empty. To copy files into the disk, you need to mount it. After it's mounted, you can copy files to it.

<code>mkdir /mnt/f256</code>

<code>sudo mount -o loop,offset=$((2048 * 512)) sdcard.img /mnt/f256</code>

<code>cp myfile.txt mnt/</code>

<code>sudo umount mnt</code>

Kernels

2025-07-17T20:22:17Z

Grenouye: fixed a typo.

; [[MicroKernel]]
: The primary kernel for the F256 machines is the TinyCore [[MicroKernel]]. This is an event based, near real-time kernel for the 65c02 and the [[Template:Main2/65816 Processor|65816]] in emulation mode (native mode is NOT supported).

; [[OpenFNXKernal]]
: Users interested in a more traditional CBM style 'kernal' may further install the [[OpenFNXKernal]] in flash along side the [[MicroKernel]] (just like any other flashed application). The code in the repo implements the basic drivers, and provides an additional kernel call for SD Card I/O, but doesn't yet include a screen editor or a unified I/O layer. It is, however, enough to run CBM BASIC. The initial code was published for those asking for a community developed replacement for the original OpenKERNAL which no longer runs on the F256 due to extensive FPGA changes. To date, however, no one has actually contributed anything back to the project. @EMWhite has greatly enhanced the code, but has not yet published his work.

Getting Started

2025-05-05T20:27:30Z

Grenouye: /* Running PGZ Files */

== Getting Powered Up ==

=== Powering your F256K ===

The F256K is powered via a standard 2.5mm DC Connector, which takes a centre-positive 12V 2A capable Power Supply.

This type of power supply is quite common. [https://www.amazon.com/Adapter-100-240V-Transformer-Charger-Security/dp/B091XSVV1Y Example 12V 2A capable power supply] (#)

(#) ''This specific power supply has not been verified (by the author) for use with the F256K. Please update this page with verified options!''

=== Powering your F256Jr ===

The F256Jr is supplied as a Mini-ITX form factor mainboard, with a standard 24 pin ATX power supply connector for power connectivity.

Since the F256Jr needs relatively little power, compared to a mini-ATX PC, a popular DC 12V 24pin Pico ATX PSU works well and is a compact solution.

* [https://www.amazon.com/dp/B08F57GKCL Pico PSU] - You power the Pico PSU via a 12V DC center-positive Power Supply source.
* [https://www.amazon.com/dp/B07MXXXBV8 12V DC center-positive A/C Adapter] - Commonly used to power the Pico PSU.
The board itself has no power switch. If you do not have a Mini-ITX case, a pin header on the board can be bridged by a jumper and thereby used instead of a proper power switch as a stop gap solution. In this picture https://wiki.c256foenix.com/images/6/64/Pinout_Jr_December_7th_Trans.png the pin header in question is shown in the lower right and is labeled with ''PW ON SPST Switch''.

== Getting programs onto the F256 ==

=== SD Card ===

Both the F256K and F256JR have an SD card slot. The device software to read the SD card is a bit touchy (it's inherited from the Commander X16 project) and doesn't work with all SD cards

* Cards should support the V2 protocol (HC or XC); older cards that only support the V1 protocol (typically 2GB or less) won't work. By contrast, the kernels for the C256 machines generally only work with V1 cards. Note that, in both cases, this is a software limitation -- all of the Foenix machines are electrically capable of using both kinds of cards.
* Partitioning should be MBR, and partition type 0x0c.
* Cards *MUST* be formatted FAT32 -- **NOT: FAT, FAT12, FAT16, or exFAT**.
* Formatting with Windows 10/11 works fine, but make sure to force FAT32 (or use the command line: <code>format /FS:FAT32 H:</code>)
* Formatting with MacOS will only work using the <code>diskutil</code> command line utility. An example usage looks like this: <code>sudo diskutil eraseDisk FAT32 [DiskName] MBRFormat /dev/[DiskNumber]</code>. You can use <code>diskutil list</code> to get the disk number for the SD Card.
* Formatting and partitioning SD cards with Linux can be done using the <code>gnome-disk-utility</code> (known simply as Disks) and is installed on most mainstream distributions of Linux. Disks will access all the drives on the computer so be sure you have the SD card selected when editing. [https://wiki.gnome.org/Apps/Disks Gnome/Disks wiki]
* FAT32 only supports a maximum partition size of 32Gb, on larger cards you will need to create multiple partitions -- however, only the first is recognized by DOS.
* Some folks have had luck formatting cards with the [https://www.sdcard.org/downloads/formatter/sd-memory-card-formatter-for-windows-download/ Official SD Association formatter for Windows].

=== Demos Archive ===

* [https://github.com/FoenixRetro/Documentation/blob/main/f256/archive Download the most recent demos archive] and expand it to the root of the flash card.

=== Debug USB port ===

* This is what most developers use as it's the most convenient. Connect the debug USB port to your PC or Mac

* You can use:
** [https://github.com/pweingar/FoenixMgr FoenixMgr] - works on Windows, Mac, Linux
*** A Python script to manage the Foenix series of retro style computers through their USB debug ports. This tool allows uploading files of various formats to system RAM, and displaying memory through various means.

** [https://github.com/Trinity-11/FoenixIDE FoenixIDE] (Windows only)
*** Development and Debugging Suite for the C256 Foenix Family of Computers.

=== wget ===
If you have the [[wifi]] configured, you can use [https://github.com/ghackwrench/F256_wget wget] to pull programs and data right off the web!

== SuperBASIC ==

The machine boots to SuperBASIC. SuperBASIC is inspired by BBC BASIC but offers quite a bit more.

* Read the [https://github.com/FoenixRetro/f256-superbasic/blob/main/reference/source/f256jr_basic_ref.pdf SuperBASIC Reference Manual].

* Watch EMWhite's excellent intro series on Youtube:
** Full Playlist here: [https://www.youtube.com/playlist?list=PLeHjTvk7NPiSqGz4REMH-S4hjYpLS2YNR EMWhite's Intro Series - Full Playlist].
** Part 1 can be viewed here:
<youtube>G_S2c_MsqYA</youtube>

To get started, you can type in a sample program at the command prompt:

<pre>
10 for i=1 to 5
20 print "Hello world"
30 next
run
</pre>

SuperBASIC is similar to CBM (Microsoft) BASIC but has some differences. For example, note in the sample above it's just <code>next</code> not <code>next i</code>.

The first 15 or so pages of the [https://github.com/FoenixRetro/f256-superbasic/blob/main/reference/source/f256jr_basic_ref.pdf SuperBASIC Reference Manual] are quite instructive.

SuperBASIC is actually much more powerful and supports structured programming (procedures, blocks etc.)

<code>dir</code> - Run this to display directory of SD card

Loading & running programs off of the SD card is similarly easy:

<pre>
load "JrWordl.bas"
run
</pre>

Similar to the C64, you can save time in loading programs from the <code>dir</code> listing by using your cursor keys to go up to the entry, typing <code>load "</code> (insert mode is active by default) etc. You can use <code>CTRL+E</code> to jump to the end of the line and use <code>CTRL+K</code> to delete any text from the cursor to the end of the line. Correctly place the closing <code>"</code> and hit <code>ENTER</code>.

<code>CTRL+C</code> acts as a "break" command and stops any running SuperBASIC program or <code>LIST</code> command.

Read built-in help/reference:

<code>/help</code> : But '''NOTE''', this erases BASIC memory! Use Backspace key to go back in menus and to exit.

Explore the included demo SuperBASIC programs:

{| class="wikitable"
! Program !! Notes !! Source
|-
| <code>JrWordl.bas</code> || Wordle game, guess 5 letter word ||
|-
| <code>mandel.bas</code> || Draws Mandlebrot set in graphics mode, takes between 2 and 3 hours || [https://github.com/Mu0n/F256KbasicBASICdoodles @Mu0n]
|-
| <code>rpg-demo.bas</code> || UI sample that shows Zelda like RPG game. Control the character with an Atari-joystick connected to JoyPort1 || @econtrerasd
|-
| <code>Problematic_Code.bas</code> || Displays scrolling starfield ||
|-
| <code>noelrl.bas</code> || Simple integer BASIC bench mark from Noel's retro lab. Completes < 3.5 seconds, compares very favourably to other retro systems! || [https://www.youtube.com/watch?v=H05hM_Guoqk Youtube]
|-
| <code>dance.bas</code> || Animates sprite of dancer || [https://github.com/Mu0n/F256KbasicBASICdoodles @Mu0n]
|-
| <code>luna.bas</code> || Displays simple scene ||
|-
| <code>blink.bas</code> || Blinks drive access light || [https://github.com/Mu0n/F256KbasicBASICdoodles @Mu0n]
|-
| <code>piano.bas</code> || Play some notes with the PSG || [https://github.com/Mu0n/F256KbasicBASICdoodles @Mu0n]
|}

=== Running PGZ Files ===

<pre>
/- file.pgz
</pre>
=== More Resources ===
=== This Wiki ===

Explore all of the content of this Wiki, to expand your F256 series knowledge!

=== Discord ===

The [https://discord.gg/9vjUEGgcUS Foenix Retro Systems Discord] is the primary place to get questions answered.

Also, if you resolve your question, and you didn't find the answer here on the Wiki, '''''please consider contributing to the Wiki''''', for the benefit of others with the same question!

=== Foenix Retro Systems Newsletter ===

Read back issues [http://apps.emwhite.org/foenixmarketplace/ here] (also a great source for sample programs).

Issues starting at #4 cover the F256 line. Issues 1-3 cover the previous version of the hardware (C256), although there are still many salient points.

Emulation

2025-05-05T20:25:20Z

Grenouye: Added missing 65816 CPU

== FoenixIDE ==
The FoenixIDE provides emulation of various Foenix Retro Systems including,
{| class="wikitable"
|+
!System
!Descripton
|-
|F256K(816)
|The F256K computer with integrated keyboard and WDC65C816 processor.
|-
|F256K
|The F256K computer with integrated keyboard and WDC65C02 processor.
|-
|Jr(816)
|The F256 Jr. computer with a WDC65C816 processor.
|-
|Jr
|The F256 Jr. computer with a WDC65C02 processor.
|-
|U+
|The C256 Foenix U+ (4Meg RAM Config) - Legacy
|-
|U
|The C256 Foenix U (2Meg RAM Config) - Legacy
|-
|C
|The C256 Foenix FMX - Legacy
|-
|B
|The C256 Foenix (original) - Legacy
|}

=== Installation ===
The current Windows installation file (FoenixIDE.Setup.msi) and source code can be found here,
'''https://github.com/Trinity-11/FoenixIDE/releases'''

== Foenijs ==
A web-based emulator in development for the F256Jr and F256K, with 65c02.

Most of the primary functions work, including all text & graphics modes with raster effects, SD Card images, USB gamepads, and PSG square wave sound. SuperBASIC runs well, but a number of .pgz programs don't quite work fully yet.

A standout feature is the CPU and stack debugging support. If your program doesn't run correctly on here, and you'd like to help from the 65c02 side of things, contact user wf2 on the Foenix Discord.

https://www.white-flame.com/foenijs/

== MAME ==
This emulator is currently under development (23 Mar 2025). See here: https://github.com/dtremblay/mame

Releases are published in GitHub and announced in Discord: https://discord.com/channels/691915291721990194/1330998392481906768

(a work-in-progress sdcard .img file containing many games, tools and media files prepared in March 2025 can be found here: https://github.com/Mu0n/F256MiscGoodies/tree/main/SDCard_Collection consult the readme of that page to get the right file)

MAME is available for Linux, Mac and Windows. Future development of the F256 machines will support the 65816, 6809 and 68000 processors.

Currently, only the F256K is partially implemented.

* Memory Management Unit (MMU) at address $0
* SD Card with SPI
* Matrix Keyboard with VIA
* Game Controllers: Atari Joysticks with VIA
* Text display, Sprites, Tiles and Bitmaps (respecting the layers)
* Interrupts: SOF, SOL, RTC, Timers, VIA0, VIA1
* Timers: Real-Time Clock (RTC), Timer0 (at 25Mhz) and Timer1 (at SOF 60 or 70Hz)
* Math processor
* Random Number Generator (RNG)
* Sound Chips: PSG (dual - stereo), OPL, SID (dual - stereo)
* Direct Memory Access (DMA)
Unimplemented features:

* UART (serial port)
* IEC
* CODEC
* NES/SNES Game Controllers
* PS/2 Mouse and Keyboard
* WIFI
* Buzzer and status LEDs
* Debug port
* DIP switches
* External Memory Cartridge

====== How to Run MAME ======
MAME has quite an extensive list of features that can be enabled and disabled.

To run F256K in full screen mode:

<code>./f256 f256k</code>

To run in window mode:

<code>./f256 f256k -window -resolution 800x600</code>

To set a disk image (for the SD Card):

<code>./f256 f256k -harddisk sdcard.img</code>

To disable sound:

<code>./f256 f256k -sound none</code>

To collect logs:

<code>./f256 f256k -log</code>

Within MAME emulator, you can see the frame rate (in percent) by pressing the '''F11''' key.

You can modify settings and key assignments using the '''TAB''' key.

You can see the debug console (to step in CPU memory and view memory values) using the back-tick key '''`'''.

Exit the emulator using the '''ESC''' key.

'''''Note''': all these keys can be modified, so these are the default settings.''

====== Creating an SD Card Image to use in MAME Emulator and Foenix IDE ======
''These instructions require a Linux Operating System or MinGW.''

Create a blank image of 64 blocks of 1 MB:

<code>dd if=/dev/zero of=sdcard.img bs=1M count=64</code>

Partition the image:

<code>parted sdcard.img --script mklabel msdos</code>

<code>parted sdcard.img --script mkpart primary fat32 1MiB 100%</code>

You need to know the starting sector for the next step. To find the '''starting''' '''sector''': <code>fdisk -l sdcard.img</code>

You'll get something like this:

<code>Device Boot Start End Sectors Size Id Type</code>

<code>sdcard.img1 2048 131071 129024 63M c W95 FAT32 (LBA)</code>

The '''starting sector''' is "2048" in the listing above.

Create a Loop Device for Formatting

Map the partition to a loop device:

<code>sudo losetup -o $((2048 * 512)) --sizelimit $((129024 * 512)) /dev/loop0 sdcard.img</code>

Format it: <code>sudo mkfs.vfat -F 32 /dev/loop0</code>

Detach it: <code>sudo losetup -d /dev/loop0</code>

The disk image is now ready, but it's empty. To copy files into the disk, you need to mount it. After it's mounted, you can copy files to it.

<code>mkdir /mnt/f256</code>

<code>sudo mount -o loop,offset=$((2048 * 512)) sdcard.img /mnt/f256</code>

<code>cp myfile.txt mnt/</code>

<code>sudo umount mnt</code>

Emulation

2025-03-23T19:48:31Z

Grenouye: Added how to specify a hard disk image in CLI.

== FoenixIDE ==
The FoenixIDE provides emulation of various Foenix Retro Systems including,
{| class="wikitable"
|+
!System
!Descripton
|-
|F256K(816)
|The F256K computer with integrated keyboard and WDC65C816 processor.
|-
|F256K
|The F256K computer with integrated keyboard and WDC65C02 processor.
|-
|Jr(816)
|The F256 Jr. computer with a WDC65C816 processor.
|-
|Jr
|The F256 Jr. computer with a WDC65C02 processor.
|-
|U+
|The C256 Foenix U+ (4Meg RAM Config) - Legacy
|-
|U
|The C256 Foenix U (2Meg RAM Config) - Legacy
|-
|C
|The C256 Foenix FMX - Legacy
|-
|B
|The C256 Foenix (original) - Legacy
|}

=== Installation ===
The current Windows installation file (FoenixIDE.Setup.msi) and source code can be found here,
'''https://github.com/Trinity-11/FoenixIDE/releases'''

== Foenijs ==
A web-based emulator in development for the F256Jr and F256K, with 65c02.

Most of the primary functions work, including all text & graphics modes with raster effects, SD Card images, USB gamepads, and PSG square wave sound. SuperBASIC runs well, but a number of .pgz programs don't quite work fully yet.

A standout feature is the CPU and stack debugging support. If your program doesn't run correctly on here, and you'd like to help from the 65c02 side of things, contact user wf2 on the Foenix Discord.

https://www.white-flame.com/foenijs/

== MAME ==
This emulator is currently under development (23 Mar 2025). See here: https://github.com/dtremblay/mame

Releases are published in GitHub and announced in Discord: https://discord.com/channels/691915291721990194/1330998392481906768

MAME is available for Linux, Mac and Windows. Future development of the F256 machines will support the 6809 and 68000 processors.

Currently, only the F256K is partially implemented.

* Memory Management Unit (MMU) at address $0
* SD Card with SPI
* Matrix Keyboard with VIA
* Game Controllers: Atari Joysticks with VIA
* Text display, Sprites, Tiles and Bitmaps (respecting the layers)
* Interrupts: SOF, SOL, RTC, Timers, VIA0, VIA1
* Timers: Real-Time Clock (RTC), Timer0 (at 25Mhz) and Timer1 (at SOF 60 or 70Hz)
* Math processor
* Random Number Generator (RNG)
* Sound Chips: PSG (dual - stereo), OPL, SID (dual - stereo)
* Direct Memory Access (DMA)
*
Unimplemented features:

* UART (serial port)
* IEC
* CODEC
* NES/SNES Game Controllers
* PS/2 Mouse and Keyboard
* WIFI
* Buzzer and status LEDs
* Debug port
* DIP switches
* External Memory Cartridge

====== How to Run MAME ======
MAME has quite an extensive list of features that can be enabled and disabled.

To run F256K in full screen mode:

<code>./f256 f256k</code>

To run in window mode:

<code>./f256 f256k -window -resolution 800x600</code>

To set a disk image (for the SD Card):

<code>./f256 f256k -harddisk sdcard.img</code>

To disable sound:

<code>./f256 f256k -sound none</code>

To collect logs:

<code>./f256 f256k -log</code>

Within MAME emulator, you can see the frame rate (in percent) by pressing the '''F11''' key.

You can modify settings and key assignments using the '''TAB''' key.

You can see the debug console (to step in CPU memory and view memory values) using the back-tick key '''`'''.

Exit the emulator using the '''ESC''' key.

'''''Note''': all these keys can be modified, so these are the default settings.''

====== Creating an SD Card Image to use in MAME Emulator and Foenix IDE ======
''These instructions require a Linux Operating System or MinGW.''

Create a blank image of 64 blocks of 1 MB:

<code>dd if=/dev/zero of=sdcard.img bs=1M count=64</code>

Partition the image:

<code>parted sdcard.img --script mklabel msdos</code>

<code>parted sdcard.img --script mkpart primary fat32 1MiB 100%</code>

You need to know the starting sector for the next step. To find the '''starting''' '''sector''': <code>fdisk -l sdcard.img</code>

You'll get something like this:

<code>Device Boot Start End Sectors Size Id Type</code>

<code>sdcard.img1 2048 131071 129024 63M c W95 FAT32 (LBA)</code>

The '''starting sector''' is "2048" in the listing above.

Create a Loop Device for Formatting

Map the partition to a loop device:

<code>sudo losetup -o $((2048 * 512)) --sizelimit $((129024 * 512)) /dev/loop0 sdcard.img</code>

Format it: <code>sudo mkfs.vfat -F 32 /dev/loop0</code>

Detach it: <code>sudo losetup -d /dev/loop0</code>

The disk image is now ready, but it's empty. To copy files into the disk, you need to mount it. After it's mounted, you can copy files to it.

<code>mkdir /mnt/f256</code>

<code>sudo mount -o loop,offset=$((2048 * 512)) sdcard.img /mnt/f256</code>

<code>cp myfile.txt mnt/</code>

<code>sudo umount mnt</code>

Emulation

2025-03-23T10:44:31Z

Grenouye: /* MAME */ Added command-line instructions to run emulator. Added key assignments in MAME emulator.

== FoenixIDE ==
The FoenixIDE provides emulation of various Foenix Retro Systems including,
{| class="wikitable"
|+
!System
!Descripton
|-
|F256K(816)
|The F256K computer with integrated keyboard and WDC65C816 processor.
|-
|F256K
|The F256K computer with integrated keyboard and WDC65C02 processor.
|-
|Jr(816)
|The F256 Jr. computer with a WDC65C816 processor.
|-
|Jr
|The F256 Jr. computer with a WDC65C02 processor.
|-
|U+
|The C256 Foenix U+ (4Meg RAM Config) - Legacy
|-
|U
|The C256 Foenix U (2Meg RAM Config) - Legacy
|-
|C
|The C256 Foenix FMX - Legacy
|-
|B
|The C256 Foenix (original) - Legacy
|}

=== Installation ===
The current Windows installation file (FoenixIDE.Setup.msi) and source code can be found here,
'''https://github.com/Trinity-11/FoenixIDE/releases'''

== Foenijs ==
A web-based emulator in development for the F256Jr and F256K, with 65c02.

Most of the primary functions work, including all text & graphics modes with raster effects, SD Card images, USB gamepads, and PSG square wave sound. SuperBASIC runs well, but a number of .pgz programs don't quite work fully yet.

A standout feature is the CPU and stack debugging support. If your program doesn't run correctly on here, and you'd like to help from the 65c02 side of things, contact user wf2 on the Foenix Discord.

https://www.white-flame.com/foenijs/

== MAME ==
This emulator is currently under development (23 Mar 2025). See here: https://github.com/dtremblay/mame

Releases are published in GitHub and announced in Discord: https://discord.com/channels/691915291721990194/1330998392481906768

MAME is available for Linux, Mac and Windows. Future development of the F256 machines will support the 6809 and 68000 processors.

Currently, only the F256K is partially implemented.

* Memory Management Unit (MMU) at address $0
* SD Card with SPI
* Matrix Keyboard with VIA
* Game Controllers: Atari Joysticks with VIA
* Text display, Sprites, Tiles and Bitmaps (respecting the layers)
* Interrupts: SOF, SOL, RTC, Timers, VIA0, VIA1
* Timers: Real-Time Clock (RTC), Timer0 (at 25Mhz) and Timer1 (at SOF 60 or 70Hz)
* Math processor
* Random Number Generator (RNG)
* Sound Chips: PSG (dual - stereo), OPL, SID (dual - stereo)
* Direct Memory Access (DMA)
*
Unimplemented features:

* UART (serial port)
* IEC
* CODEC
* NES/SNES Game Controllers
* PS/2 Mouse and Keyboard
* WIFI
* Buzzer and status LEDs
* Debug port
* DIP switches
* External Memory Cartridge

====== How to Run MAME ======
MAME has quite an extensive list of features that can be enabled and disabled.

To run F256K in full screen mode:

<code>./f256 f256k</code>

To run in window mode:

<code>./f256 f256k -window -resolution 800x600</code>

To disable sound:

<code>./f256 f256k -sound none</code>

To collect logs:

<code>./f256 f256k -log</code>

Within MAME emulator, you can see the frame rate (in percent) by pressing the '''F11''' key.

You can modify settings and key assignments using the '''TAB''' key.

You can see the debug console (to step in CPU memory and view memory values) using the back-tick key '''`'''.

Exit the emulator using the '''ESC''' key.

'''''Note''': all these keys can be modified, so these are the default settings.''

====== Creating an SD Card Image to use in MAME Emulator and Foenix IDE ======
''These instructions require a Linux Operating System or MinGW.''

Create a blank image of 64 blocks of 1 MB:

<code>dd if=/dev/zero of=sdcard.img bs=1M count=64</code>

Partition the image:

<code>parted sdcard.img --script mklabel msdos</code>

<code>parted sdcard.img --script mkpart primary fat32 1MiB 100%</code>

You need to know the starting sector for the next step. To find the '''starting''' '''sector''': <code>fdisk -l sdcard.img</code>

You'll get something like this:

<code>Device Boot Start End Sectors Size Id Type</code>

<code>sdcard.img1 2048 131071 129024 63M c W95 FAT32 (LBA)</code>

The '''starting sector''' is "2048" in the listing above.

Create a Loop Device for Formatting

Map the partition to a loop device:

<code>sudo losetup -o $((2048 * 512)) --sizelimit $((129024 * 512)) /dev/loop0 sdcard.img</code>

Format it: <code>sudo mkfs.vfat -F 32 /dev/loop0</code>

Detach it: <code>sudo losetup -d /dev/loop0</code>

The disk image is now ready, but it's empty. To copy files into the disk, you need to mount it. After it's mounted, you can copy files to it.

<code>mkdir /mnt/f256</code>

<code>sudo mount -o loop,offset=$((2048 * 512)) sdcard.img /mnt/f256</code>

<code>cp myfile.txt mnt/</code>

<code>sudo umount mnt</code>

Emulation

2025-03-23T10:33:41Z

Grenouye: /* MAME */ Added features implemented up to March 23, 2025. How to setup a disk image.

Emulation

2025-01-26T20:36:17Z

Grenouye: Added the MAME emulator

Software for 6502

2024-12-17T22:02:58Z

Grenouye: /* Games */ Added Tetris to the list.

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.

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/.

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

== Demos ==
{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|balls
|Draw a good quantity of multiplexed sprites, fast. Balls bouncing around
|celton
|pgz
|https://github.com/FoenixRetro/demos/blob/main/MultiplexedSprites.md
|-
|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
|-
|f256_life
|An implementation of Conway's game of life
|mgr42
|pgz
|https://github.com/rmsk2/f256_life
|-
|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://discordapp.com/channels/691915291721990194/934618943400837130/1188633998663098398 if you have Dec23 FPGA load or newer
https://discordapp.com/channels/691915291721990194/934618943400837130/1188633118194794527 if you have an older FPGA load
|-
|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
|-
|Bombsweeper
|Bomb sweeper port
|beethead
|pgz
|https://discord.com/channels/691915291721990194/855689509520932885/1196352934083035156
|-
|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
|-
|Cosmic
|Shoot 'em up
|beethead
|pgz
|https://discordapp.com/channels/691915291721990194/1054250238308790342/1175982979537969214
|-
|F256 two to the power of eleven
|Port of the puzzle game of 2048
|mgr42
|pgz
|https://github.com/rmsk2/F256_2048<nowiki/>
|-
|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
|-
|Maze-Munch
|Pac-Man clone
|SprySloth
|pgz
|https://github.com/cmassat/Maze-Munch
|-
|Ski-Jr
|Ski game downhill
|digarok
|basic
|https://github.com/digarok/superbasic-traveler/blob/main/ski-jr.bas
|-
|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]
|-
|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]
|-
|fillerup
|Fill 'er Up (WIP)
Qix-like game
|Scott (xDraconian)
|pgx
atari joystick
|https://github.com/scttgs0/Fill-er-up
|-
|livewire
|Livewire (WIP)
Tempest-like game
|Scott (xDraconian)
|pgx
atari joystick
|https://github.com/scttgs0/Livewire
|-
|pdefense
|Planetary Defense (WIP)
|Scott (xDraconian)
|pgx
mouse
atari joystick
|https://github.com/scttgs0/PlanetaryDefense
|-
|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/>
|-
|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
|-
|Flight Simulator
|flying simulator
|sduensin
|pgz
|https://cdn.discordapp.com/attachments/1225481966200029286/1227764847819620454/shotel.pgz
|-
|}

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

== Music ==

{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|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.
|-
|jrtracker
|Tracker based in basic and uses the PSG
|contrerasd
|basic
|https://ptb.discord.com/channels/691915291721990194/1008139105386889346/1188292876984143983
|-
|tracker2
|Same tracker, but using both PSGs
|contrerasd
|basic
|https://discord.com/channels/691915291721990194/975117322836656138/1210809081577865257
|-
|modo
|MOD player using the PSG
|dwsJason and digarok
|pgz
|https://discordapp.com/channels/691915291721990194/855689509520932885/1190723114661859429
|-
|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'''''<nowiki/> '''''"yourmusicfile", $01000'''''
followed by run<nowiki/>ning<nowiki/> this program with '''''/- playvgm.pgx'''''
|}

== Uti<nowiki/>lities ==

{| class="wikitable"
|+
!Program
!Descrip<nowiki/>tion
!Author
!Notes on running
!Link
|-
|wget<nowiki/>
|<nowiki/>fetches a file from a http address if you have a network connection active
|gadget
|<nowiki/>pgz/flash
|https://github.com/ghackwrench/F256_wget
|
|-
|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
|https://github.com/rmsk2/f256_dcopy
|
|-
|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]
|
|-
|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
|
|-
|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
|
|-
|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
|
|-
|moreorless
|A text editor for the Foenix 256 line of computers
|mgr42
|pgz
|https://github.com/rmsk2/moreorless/releases/
|
|-
|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
|
|}

== Sample Code ==

{| class="wikitable"
|+
!Program
!Description
!Author
!Notes on running
!Link
|-
|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
|-
|tcp example
|connects to a server and gets typed in text echoed back to you
|gadget
|$2000
|https://github.com/ghackwrench/F256_example_tcp
|-
|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
|}

Building SuperBASIC itself

2024-11-22T20:36:39Z

Grenouye: /* Building SuperBASIC from Scratch */

= '''Building SuperBASIC from Scratch''' =
If you are using Git bash for a command-line (on MS Windows), you need to tell bash that you're not a real Linux machine:
export OS=cygwin
I had to add the make command by following the instructions here: https://gist.github.com/evanwill/0207876c3243bbb6863e65ec5dc3f058#make. From ezwinports, use the '''make without guile''' zip file.

@mgr42 [said in Discord](https://discord.com/channels/691915291721990194/1028045613104910368/1191727753205129227) "''I was able to build superbasic from source using the following process:''"

* Install python-is-python3 on your Debian or Ubuntu machine
* Install `64tass`. The version available in the Ubuntu repos compiles the source without errors.
* Execute `git clone https://github.com/FoenixRetro/f256-superbasic.git`
* Execute `git clone https://github.com/WartyMN/Foenix-F256JR-bootscreens.git`
* Change into the directory `f256-superbasic/source`
* Execute `make`
* If this succeeds there will be an updated file called `basic.rom` in the directory `f256-superbasic/source/build`
* Change into the directory `f256-superbasic/source/build`
* Execute the command `python splitrom.py`
* If this succeeds there will be 4 updated files called `sb01.bin`, `sb02.bin`, `sb03.bin` and `sb04.bin` which can be flashed to the F256 Jr./K

The output of make:

[[File:Make-super-basic.png|Output of make]]

I modified the 00start.asm file on line #30 to change the F256Header from "basic" to "sbasic", this way it shows up in the system commands as a separate command.

F256Header:
.text $f2,$56 ; Signature
.byte 4 ; 4 blocks
.byte 4 ; mount at $8000
.word Boot ; Start here
.byte 1 ; version
.byte 0 ; reserved
.byte 0 ; reserved
.byte 0 ; reserved
.text "sbasic",0 ; name of program.
.text 0 ; arguments
.text "The SuperBASIC environment.",0 ; description
After splitting the ==basic.rom== into bins, I then flashed with this CSV:
08,sb01.bin
09,sb02.bin
0a,sb03.bin
0b,sb04.bin
After reboot, type `/sbasic`.

Type the following in the F256K in 'sbasic'
print ?(8+4)
This command is short for print peek(12).

Result should be `'''72'''`.

Building SuperBASIC itself

2024-11-22T20:36:25Z

Grenouye: /* Building SuperBASIC from Scratch */

= '''Building SuperBASIC from Scratch''' =
If you are using Git bash for a command-line (on MS Windows), you need to tell bash that you're not a real Linux machine:
export OS=cygwin
I had to add the make command by following the instructions here: https://gist.github.com/evanwill/0207876c3243bbb6863e65ec5dc3f058#make. From ezwinports, use the '''make without guile''' zip file.

@mgr42 [said in Discord](https://discord.com/channels/691915291721990194/1028045613104910368/1191727753205129227) "''I was able to build superbasic from source using the following process:''"

* Install python-is-python3 on your Debian or Ubuntu machine
* Install `64tass`. The version available in the Ubuntu repos compiles the source without errors.
* Execute `git clone https://github.com/FoenixRetro/f256-superbasic.git`
* Execute `git clone https://github.com/WartyMN/Foenix-F256JR-bootscreens.git`
* Change into the directory `f256-superbasic/source`
* Execute `make`
* If this succeeds there will be an updated file called `basic.rom` in the directory `f256-superbasic/source/build`
* Change into the directory `f256-superbasic/source/build`
* Execute the command `python splitrom.py`
* If this succeeds there will be 4 updated files called `sb01.bin`, `sb02.bin`, `sb03.bin` and `sb04.bin` which can be flashed to the F256 Jr./K

The output of make:
[[File:Make-super-basic.png|Output of make]]

I modified the 00start.asm file on line #30 to change the F256Header from "basic" to "sbasic", this way it shows up in the system commands as a separate command.

F256Header:
.text $f2,$56 ; Signature
.byte 4 ; 4 blocks
.byte 4 ; mount at $8000
.word Boot ; Start here
.byte 1 ; version
.byte 0 ; reserved
.byte 0 ; reserved
.byte 0 ; reserved
.text "sbasic",0 ; name of program.
.text 0 ; arguments
.text "The SuperBASIC environment.",0 ; description
After splitting the ==basic.rom== into bins, I then flashed with this CSV:
08,sb01.bin
09,sb02.bin
0a,sb03.bin
0b,sb04.bin
After reboot, type `/sbasic`.

Type the following in the F256K in 'sbasic'
print ?(8+4)
This command is short for print peek(12).

Result should be `'''72'''`.

Building SuperBASIC itself

2024-11-22T20:36:03Z

Grenouye: Removed markdown code.

= '''Building SuperBASIC from Scratch''' =
If you are using Git bash for a command-line (on MS Windows), you need to tell bash that you're not a real Linux machine:
export OS=cygwin
I had to add the make command by following the instructions here: https://gist.github.com/evanwill/0207876c3243bbb6863e65ec5dc3f058#make. From ezwinports, use the '''make without guile''' zip file.

@mgr42 [said in Discord](https://discord.com/channels/691915291721990194/1028045613104910368/1191727753205129227) "''I was able to build superbasic from source using the following process:''"

* Install python-is-python3 on your Debian or Ubuntu machine
* Install `64tass`. The version available in the Ubuntu repos compiles the source without errors.
* Execute `git clone https://github.com/FoenixRetro/f256-superbasic.git`
* Execute `git clone https://github.com/WartyMN/Foenix-F256JR-bootscreens.git`
* Change into the directory `f256-superbasic/source`
* Execute `make`
* If this succeeds there will be an updated file called `basic.rom` in the directory `f256-superbasic/source/build`
* Change into the directory `f256-superbasic/source/build`
* Execute the command `python splitrom.py`
* If this succeeds there will be 4 updated files called `sb01.bin`, `sb02.bin`, `sb03.bin` and `sb04.bin` which can be flashed to the F256 Jr./K

The output of make:
[[File:Make-super-basic.png|thumb|Output of make]]

I modified the 00start.asm file on line #30 to change the F256Header from "basic" to "sbasic", this way it shows up in the system commands as a separate command.

F256Header:
.text $f2,$56 ; Signature
.byte 4 ; 4 blocks
.byte 4 ; mount at $8000
.word Boot ; Start here
.byte 1 ; version
.byte 0 ; reserved
.byte 0 ; reserved
.byte 0 ; reserved
.text "sbasic",0 ; name of program.
.text 0 ; arguments
.text "The SuperBASIC environment.",0 ; description
After splitting the ==basic.rom== into bins, I then flashed with this CSV:
08,sb01.bin
09,sb02.bin
0a,sb03.bin
0b,sb04.bin
After reboot, type `/sbasic`.

Type the following in the F256K in 'sbasic'
print ?(8+4)
This command is short for print peek(12).

Result should be `'''72'''`.

Building SuperBASIC itself

2024-11-22T20:27:06Z

Grenouye: Created page with "***Using the Git bash command, change the OS: `export OS=cygwin`.*** I had to add the make command by following the instructions here: https://gist.github.com/evanwill/0207876c3243bbb6863e65ec5dc3f058#make. From ezwinports, use the **make without guile** zip file. @mgr42 [said in Discord](https://discord.com/channels/691915291721990194/1028045613104910368/1191727753205129227) "*I was able to build superbasic from source using the following process:*" - Inst..."

***Using the Git bash command, change the OS: `export OS=cygwin`.***

I had to add the make command by following the instructions here: https://gist.github.com/evanwill/0207876c3243bbb6863e65ec5dc3f058#make. From ezwinports, use the **make without guile** zip file.

@mgr42 [said in Discord](https://discord.com/channels/691915291721990194/1028045613104910368/1191727753205129227) "*I was able to build superbasic from source using the following process:*"

- Install python-is-python3 on your Debian or Ubuntu machine
- Install `64tass`. The version available in the Ubuntu repos compiles the source without errors.
- Execute `git clone https://github.com/FoenixRetro/f256-superbasic.git`
- Execute `git clone https://github.com/WartyMN/Foenix-F256JR-bootscreens.git`
- Change into the directory `f256-superbasic/source`
- Execute `make`
- If this succeeds there will be an updated file called `basic.rom` in the directory `f256-superbasic/source/build`
- Change into the directory `f256-superbasic/source/build`
- Execute the command `python splitrom.py`
- If this succeeds there will be 4 updated files called `sb01.bin`, `sb02.bin`, `sb03.bin` and `sb04.bin` which can be flashed to the F256 Jr./K

The output of make:
[[File:Make-super-basic.png|thumb|Output of make]]

I modified the 00start.asm file on line #30 to change the F256Header from "basic" to "sbasic", this way it shows up in the system commands as a separate command.
```assembly
F256Header:
.text $f2,$56 ; Signature
.byte 4 ; 4 blocks
.byte 4 ; mount at $8000
.word Boot ; Start here
.byte 1 ; version
.byte 0 ; reserved
.byte 0 ; reserved
.byte 0 ; reserved
.text "sbasic",0 ; name of program.
.text 0 ; arguments
.text "The SuperBASIC environment.",0 ; description
```

After splitting the ==basic.rom== into bins, I then flashed with this CSV:
```
08,sb01.bin
09,sb02.bin
0a,sb03.bin
0b,sb04.bin
```

After reboot, type `/sbasic`.
Performing the `print ?(8+4)` results in `72`.

File:Make-super-basic.png

2024-11-22T20:26:51Z

Grenouye:

Output of make

Export Aseprite Tileset

2024-01-31T22:40:09Z

Grenouye: New page.

====== This LUA script file needs to be placed in Aseprite's "scripts" folder. ======
-- export tileset.lua
-- Copyright (C) 2022 Daniel Tremblay
--
-- This file is released under the terms of the MIT license.

if TilesetMode == nil then return app.alert "Use Aseprite v1.3" end

local lay = app.activeLayer
if not lay.isTilemap then return app.alert "No active tilemap layer" end

local tileset = lay.tileset

local dlg = Dialog("Export Tileset")
dlg:file{ id="filename", label="Export to Tilemap file:", save=true, focus=true,
filename=app.fs.joinPath(app.fs.filePath(lay.sprite.filename), "tileset.png") }
:label{ label="Number of Tiles to be exported", text=tostring(#tileset) }

:separator()
:number { id="tilemap_cols", label="Number of columns in Tilemap:", text="16" }
:check { id="ask_overwrite", label="Ask before overwrite existing Tilemap file", selected=true }
:check { id="tiles_extruded", label="Extrude Tiles in Tilemap", selected=false }
:check { id="keep_sprite_frames", label="Keep generated sprite frames open", selected=false }
:check { id="open_generated", label="Open generated Tilemap", selected=false }

:separator()
:button{ text="&Export", focus=true, id="ok" }
:button{ text="&Cancel" }
:show()

-- Data validation
local data = dlg.data
if not data.ok then return end

local spec = lay.sprite.spec
local grid = tileset.grid
local size = grid.tileSize

-- Create a new sprite with the dimension of one single tile
local newSpr = Sprite(size.width, size.height, lay.sprite.colorMode)

-- give the new sprite the same palette as the source sprite
newSpr:setPalette(lay.sprite.palettes[1])

-- First copy first tile into sprite frame 1
local tile = tileset:getTile(0)
newSpr.cels[1].image = tile

-- Then create new frame and copy each tile into a new frame of sprite

for i = 1, #tileset - 1 do
app.command.NewFrame { ["content"]="current" }
local tile = tileset:getTile(i)
newSpr.cels[i + 1].image = tile
end

if app.apiVersion >= 3 then
newSpr.filename = "sprite frames"
end

-- Export sprite frames as an extruded sprite sheet
app.command.ExportSpriteSheet{
ui=false,
askOverwrite=data.ask_overwrite,
type=SpriteSheetType.ROWS,
columns=data.tilemap_cols,
textureFilename=data.filename,
extrude=data.tiles_extruded,
openGenerated=data.open_generated
}

-- Close sprite frames again
if data.keep_sprite_frames == false then
newSpr:close()
end

Export Aseprite Tilemap

2024-01-31T22:37:04Z

Grenouye: New Page

===== This LUA script file needs to be placed in Aseprite's "scripts" folder. =====
-- export tilemap.lua
-- Copyright (C) 2022 Daniel Tremblay
--
-- This file is released under the terms of the MIT license.

local spr = app.activeSprite
local pc = app.pixelColor
if not spr then return print "No active sprite" end

if ColorMode.TILEMAP == nil then ColorMode.TILEMAP = 4 end
assert(ColorMode.TILEMAP == 4)

local output_folder = app.fs.filePath(spr.filename)

local function write_foenix_data(filename, data)
local file = io.open(filename, "wb")
local str = string.char(table.unpack(data))
file:write(str)
file:close()
end

local function export_cel(cel)
local t = {
frame=cel.frameNumber-1,
bounds={ x=cel.bounds.x,
y=cel.bounds.y,
width=cel.bounds.width,
height=cel.bounds.height }
}

if cel.image.colorMode == ColorMode.TILEMAP then
local tilemap = cel.image
-- save tilemap
t.tilemap = { width=tilemap.width,
height=tilemap.height,
tiles={} }
for it in tilemap:pixels() do
table.insert(t.tilemap.tiles, pc.tileI(it()))
end
else
-- save regular cel
image_n = image_n + 1
local imageFn = fs.joinPath(output_folder, "image" .. image_n .. ".png")
cel.image:saveAs(imageFn)
t.image = imageFn
end

fill_user_data(t, cel)
return t
end

----------------------------------------------------------------------
-- Creates output folder
-- fs.makeDirectory(output_folder) -- don't!!

----------------------------------------------------------------------
-- Write /sprite.json file in the output folder

local tilemapFile = app.fs.joinPath(output_folder, "tilemap.tlm")

local data = {}
-- add a tile because Vicky II requires it
table.insert(data,0)
table.insert(data,0)
-- iterate over each layer
for _,layer in ipairs(spr.layers) do
-- iterate over each cel
for _,cel in ipairs(layer.cels) do
local tilemap = cel.image
for it in tilemap:pixels() do
table.insert(data, pc.tileI(it()))
table.insert(data, 0)
end
end
--data[y*grid.width*2 + x*2]=grid.tileIndex
end

--for i=1,1000 do data[i] = math.random(0,255) end

write_foenix_data(tilemapFile, data)

Tools & Scripts

2024-01-31T22:34:26Z

Grenouye: Added two links to Aseprite LUA scripts.

== F256 Machines Game Development Tools ==

=== Sprite Creation Tools & Scripts ===

{| class="wikitable"
! Tool !! Link
! --- !! Notes
|-
| style="white-space:nowrap;"| Aseprite
| style="white-space:nowrap;"| https://www.aseprite.org/
|
| style="white-space:nowrap;" |Aseprite can be used to create sprites animation or Tiles Sets.
|}

==== Scripts ====

=== Tile Creation Tools & Scripts ===
If you use Aseprite, you can convert your tile drawings to tilesets and tilemaps using the following scripts:

* [[Export Aseprite Tilemap]]
* [[Export Aseprite Tileset]]

HOWTO

2024-01-31T22:27:48Z

Grenouye: Added a link to the SNES/NES example

* [[Wifi|Set up wifi.]]
* [[Wget from pc|Fetch files from your PC using wget.]]
* [[Use the SNES/NES controller in Assembly]]

Use the SNES/NES controller in Assembly

2024-01-31T22:26:41Z

Grenouye: Added description

=== '''; Code contributed by Stefany Allaire on Discord''' ===

=== ; This is test code that goes through all the ports and mux the NES and SNES... ===
NES_CTRL = $D880

NES_STAT = $D880

NES_EN = $01

NES_MODE = $04

NES_TRIG = $80

NES_DONE = $40

NES_JOY0 = $D884

NES_JOY1 = $D886

NES_JOY2 = $D888

NES_JOY3 = $D88A

SNES_JOY0_LO = $D884

SNES_JOY0_HI = $D885

SNES_JOY1_LO = $D886

SNES_JOY1_HI = $D887

SNES_JOY2_LO = $D888

SNES_JOY2_HI = $D889

SNES_JOY3_LO = $D88A

SNES_JOY3_HI = $D88B

Test_4N4S:

jsr SetIOPage0

'''; Test NES First'''

'''; Enable and Begin a Sample'''

NES_Start_Again:

lda #NES_EN

sta NES_CTRL

lda NES_CTRL

ora #NES_TRIG

sta NES_CTRL

and #~NES_TRIG

sta NES_CTRL

NESWait2beDone

lda NES_STAT

and #NES_DONE

cmp #NES_DONE

bne NESWait2beDone

'''; When here, the Joystick Sampling is done'''

lda NES_JOY0

eor #$FF

ldx #$00

jsr Byte2Hex

lda NES_JOY1

eor #$FF

ldx #$03

jsr Byte2Hex

lda NES_JOY2

eor #$FF

ldx #$06

jsr Byte2Hex

lda NES_JOY3

eor #$FF

ldx #$09

jsr Byte2Hex

lda NES_JOY3

eor #$FF

and #$C0

cmp #$C0

beq NESDoneWithTest

'''; Let's do the SNES'''

lda #NES_EN | NES_MODE

sta NES_CTRL

lda NES_CTRL

ora #NES_TRIG

sta NES_CTRL

and #~NES_TRIG

sta NES_CTRL

SNESWait2beDone

lda NES_STAT

and #NES_DONE

cmp #NES_DONE

bne SNESWait2beDone

'''; When here, the Joystick Sampling is done'''

lda SNES_JOY0_HI

and #$0F

eor #$0F

ldx #$50

jsr Byte2Hex

lda SNES_JOY0_LO

eor #$FF

ldx #$52

jsr Byte2Hex

lda SNES_JOY1_HI

and #$0F

eor #$0F

ldx #$55

jsr Byte2Hex

lda SNES_JOY1_LO

eor #$FF

ldx #$57

jsr Byte2Hex

lda SNES_JOY2_HI

and #$0F

eor #$0F

ldx #$5A

jsr Byte2Hex

lda SNES_JOY2_LO

eor #$FF

ldx #$5C

jsr Byte2Hex

lda SNES_JOY3_HI

and #$0F

eor #$0F

ldx #$5F

jsr Byte2Hex

lda SNES_JOY3_LO

eor #$FF

ldx #$61

jsr Byte2Hex

jmp NES_Start_Again

NESDoneWithTest:

lda #$00

sta NES_CTRL

rts

Byte2Hex:

sta $50

stx $51

jsr SetIOPage2

'''; Hi Part'''

lda $50

and #$F0

lsr a

lsr a

lsr a

lsr a

tax

lda HEX, x ;

ldx $51

sta $c320,x

'''; Low Part'''

lda $50

and #$0F

tax

lda HEX, x

ldx $51

sta $c321,x

jsr SetIOPage0

rts

Use the SNES/NES controller in Assembly

2024-01-31T22:24:36Z

Grenouye: Copied the code from Discord

'''; Code contributed by Stefany Allaire on Discord'''

NES_CTRL = $D880

NES_STAT = $D880

NES_EN = $01

NES_MODE = $04

NES_TRIG = $80

NES_DONE = $40

NES_JOY0 = $D884

NES_JOY1 = $D886

NES_JOY2 = $D888

NES_JOY3 = $D88A

SNES_JOY0_LO = $D884

SNES_JOY0_HI = $D885

SNES_JOY1_LO = $D886

SNES_JOY1_HI = $D887

SNES_JOY2_LO = $D888

SNES_JOY2_HI = $D889

SNES_JOY3_LO = $D88A

SNES_JOY3_HI = $D88B

Test_4N4S:

jsr SetIOPage0

'''; Test NES First'''

'''; Enable and Begin a Sample'''

NES_Start_Again:

lda #NES_EN

sta NES_CTRL

lda NES_CTRL

ora #NES_TRIG

sta NES_CTRL

and #~NES_TRIG

sta NES_CTRL

NESWait2beDone

lda NES_STAT

and #NES_DONE

cmp #NES_DONE

bne NESWait2beDone

'''; When here, the Joystick Sampling is done'''

lda NES_JOY0

eor #$FF

ldx #$00

jsr Byte2Hex

lda NES_JOY1

eor #$FF

ldx #$03

jsr Byte2Hex

lda NES_JOY2

eor #$FF

ldx #$06

jsr Byte2Hex

lda NES_JOY3

eor #$FF

ldx #$09

jsr Byte2Hex

lda NES_JOY3

eor #$FF

and #$C0

cmp #$C0

beq NESDoneWithTest

'''; Let's do the SNES'''

lda #NES_EN | NES_MODE

sta NES_CTRL

lda NES_CTRL

ora #NES_TRIG

sta NES_CTRL

and #~NES_TRIG

sta NES_CTRL

SNESWait2beDone

lda NES_STAT

and #NES_DONE

cmp #NES_DONE

bne SNESWait2beDone

'''; When here, the Joystick Sampling is done'''

lda SNES_JOY0_HI

and #$0F

eor #$0F

ldx #$50

jsr Byte2Hex

lda SNES_JOY0_LO

eor #$FF

ldx #$52

jsr Byte2Hex

lda SNES_JOY1_HI

and #$0F

eor #$0F

ldx #$55

jsr Byte2Hex

lda SNES_JOY1_LO

eor #$FF

ldx #$57

jsr Byte2Hex

lda SNES_JOY2_HI

and #$0F

eor #$0F

ldx #$5A

jsr Byte2Hex

lda SNES_JOY2_LO

eor #$FF

ldx #$5C

jsr Byte2Hex

lda SNES_JOY3_HI

and #$0F

eor #$0F

ldx #$5F

jsr Byte2Hex

lda SNES_JOY3_LO

eor #$FF

ldx #$61

jsr Byte2Hex

jmp NES_Start_Again

NESDoneWithTest:

lda #$00

sta NES_CTRL

rts

Byte2Hex:

sta $50

stx $51

jsr SetIOPage2

'''; Hi Part'''

lda $50

and #$F0

lsr a

lsr a

lsr a

lsr a

tax

lda HEX, x ;

ldx $51

sta $c320,x

'''; Low Part'''

lda $50

and #$0F

tax

lda HEX, x

ldx $51

sta $c321,x

jsr SetIOPage0

rts