FujiNet is a public project. Our goal is to get this network adapter platform ported and running on every single retro-computing and retro-gaming platform on planet Earth. To do this, we need your help.

Types of Help Needed

Application Software (running on the target machine)

FujiNet users need Application software that can run on each of the target systems. If you can write software, or manage to coax something usable out of a large language model, you can help get software written for users.

Since we are a public project, all of our software can not only be run directly from a FujiNet, all of the source code for our projects is available on our GitHub: https://github.com/FujiNetWIFI/fujinet-apps

Application Software Languages

FujiNet is designed to be easy to write software in any language either natively or via cross development, since we try to integrate into the operating system of each target machine. Languages include:

  • BASIC
  • Assembler
  • C
  • Pascal
  • Is there one we are missing? let us know!

In addition to client side languages, any desired server side language can be used and beneficial, such as:

  • C/C++
  • Go
  • Python
  • JavaScript (node.js)
  • Rust
  • …whatever

Games

It’s no secret that FujiNet opens up a new door for cross-platform gaming to a wide variety of vintage computers and game consoles. We have written two turn-based games, 5 Card Stud Poker and Fujitzee (a Yahtzee game) which are now available for Atari, Commodore, Apple2, TRS-80 Color Computer, Coleco Adam and MS-DOS (vintage PC). We have also written a gaming lobby where games can advertise their availability and capacity (http://fujinet.online:8080/).

For the first time, cross platform game-play can, and has occurred across many disparate platforms, even between vintage gaming consoles and computers!

MS-DOS Version of 5 Card Stud uses CGA with palette remapping, and can even work on PCjr systems with 128K of RAM, Tandy, and other systems. It’s very compatible.

And yes, even on game consoles like the Atari 2600 VCS:

Other multiplayer games could be written:

  • More card games (e.g. Texas Hold-Em)
  • Role Playing Games (RPGs)
  • Quiz Games
  • and so on.

Non-Games

Seems silly, doesn’t it? But yes, things that aren’t games, like:

  • Google Drive clients
  • Apps for popular websites (e.g. a full Mastodon client)
  • Network-Aware Development Tools
  • Special things for Art Installations
  • and more…

Documentation Help

We have a lot of documentation that has been written on the Wiki https://github.com/FujiNetWIFI/fujinet-firmware/wiki that needs to be distilled into users guides. We need people who can:

  • Work through the wiki, finding useful information.
  • Distill it down into useful guides that people can understand.
  • Get it together so it can be bundled with each new FujiNet.

It doesn’t matter what format it’s in, use your favorite format, the information is what’s important. I started working on a user’s guide for the Atari systems in DocBook (because I wanted something that could be typeset as a full manual) Its GitHub is here: https://github.com/FujiNetWIFI/fujinet-manuals

Firmware Help

FujiNet itself is 99% firmware. It runs on micro-controllers like the ESP32. To bring FujiNet to each new platform, we need to make bus, device, and media code for each new platform, using the existing ones as a reference. Some facts about the implementation:

  • FujiNet uses ESP-IDF for the ESP32 implementation.
  • It is written in C++.
  • We use PlatformIO (https://platformio.org/) for building and maintaining the code.
  • The firmware code is in GitHub (https://github.com/FujiNetWIFI/fujinet-firmware)
  • It is split into several major sections, buses, devices, media, network adapters, and miscellaneous code.
  • It can be built from the command line via build.sh, or via an IDE such as VS.Code

As we do more bring-ups, we can help show how the firmware can be extended to add support for new buses and architectures to facilitate each new platform.

Hardware Help

Each FujiNet connects to a target system in a way that should always provide the maximum integration benefit for the target computer and the user. This means that every hardware implementation of FujiNet is unique for each target system, and for some targets (such as PC) there will be multiple types of bus connections.

As with Software, Documentation, and Firmware, all of the hardware that gets designed is available to build via GitHub. We publish everything required from the bill of materials (BOM) to the schematics and Gerber files needed to completely fabricate each and every device on GitHub: https://github.com/FujiNetWIFI/fujinet-hardware

Phase 1: Serial Buses: Successful.

The first phase of FujiNet development was marked by implementing against computers that have serial bus connections, such as the Atari, Coleco Adam, Atari Lynx, RS-232, and the serial interface on the TRS-80 Color Computer. We also implemented against more challenging serial buses such as the SmartPort for the Apple II target.

Phase 2: Parallel Buses (ISA, Cartridge connectors, etc.): Partially There.

While many vintage computers had serial buses that could easily be attached to the UART of a FujiNet’s ESP32, many other systems have parallel bus connections that connect directly to a central processor’s bus. To connect to these systems, we need to implement hardware that can provide a communication pathway to the ESP32 via decoded addresses on a given bus. While we have some expertise in developing such an interface, we could use platform specific help to fill in various gaps to get FujiNet onto each and every system that can use one.

Our Approach for Phase 2: Add an RP2350 to the front.

By adding an RP2350 to the front, we see a pathway to adding a microcontroller with programmable I/O macro-blocks that potentially negates the need for a complex programmable logic device (CPLD) or field programmable gate array (FPGA) and thus keep the production and retail costs down for each and every FujiNet, while making it possible to use most of the flexibility expected from programmable logic arrays, such as adapting to different bus topologies and timing considerations using languages like C.

We have proven that such an approach can work with two bus designs:

  • Atari 2600 (VCS)
  • TRS-80 Color Computer (Bus version)
Atari 2600 (VCS) FujiNet with RP2040 and ESP32.

In both cases, the RP2040 or RP2350 reacts to bus activity using the programmable IO (PIO) macro-blocks, and provides the I/O address decoding and parallel data pathways required to talk to the on-board ESP32 microcontroller which runs all the FujiNet firmware providing all the different devices.

What we need: People to take the work we’ve done, and target it to other bus interfaces, such as:

  • ZX Spectrum
  • PC ISA bus
  • Amstrad CPC bus
  • Heathkit Benton Harbor Bus
  • S-100
  • SCSI
  • Intellivision Cartridge Port
  • Bally Astrocade Cartridge Port
  • NES Cartridge port or Expansion Port
  • BBC Micro 1MHz Bus
  • MSX Cartridge Port
  • Mattel Aquarius Cartridge Port
  • NEC PC-8801, PC-9801, PC-6001
  • Sharp X68000
  • DEC PDP-8/PDP-11
  • TRS-80 Model 1/2/3/4/12/16/6000
  • and on…and on…

Do you see a system here that you can help design a hardware card for? You can help!

Intellivision FujiNet playing 5cs? Yes. It’s possible.

I Want To Help! How can I get in Touch?

Contact Form

Of course, there is a contact form on the side of this page. It goes to @mozzwald and he’ll fan it out to one of the rest of us, as needed.

Discord

We hang out on Discord, and are constantly engaging in development discussion. Feel free to join: https://discord.gg/2Ce9guX. Pick a spot and start asking stupid questions. We’ll funnel you in.

Thank You

Thank you for taking the time to read this.

Thank you for using FujiNet and making it all that it currently is.

Thank you for wanting to help make it even better.

Contact Us: