Project Inspiration Thread!


I have a lot of project ideas I want to work on. However…I’ve been so busy running TinyFPGA that I don’t have much time for implementing projects on the boards myself. That’s pretty ironic since I created these boards in the first place for myself to use :smile:

That said, here are my thoughts on projects I would love to see and use myself.

Open Source Microcontroller Toolkit

A toolkit for piecing together your own microcontroller built to your specifications. The user building the microcontroller doesn’t need to know how to write a single line of Verilog. Instead, the toolkit allows them to pick and chose CPU cores and peripherals to make their own custom microcontroller that suites their needs.

To ensure interoperability, all the CPU cores and peripherals use Wishbone B4 Spec. Each CPU core or peripheral is packaged in a standard way along with some meta-data exposed to the toolkit. Both a command-line tool as well as a GUI exist for users to customize their micro-controller. The toolkit can stitch together the components and use the appropriate tools to synthesize the design, compile the code, and download the combined design and program to the FPGA board.

CPU cores:

  • The JOP CPU is the Java Optimized CPU. It runs Java efficiently and with predictable worst-case execution times. Very slick. I’ve always wanted this in a tiny form-factor and now it’s possible with the TinyFPGA boards. Source code is available on github.
  • RISC V microcontroller. Use the PicoRV32 core and implement an open-source RISC microcontroller.
  • The old 6502 has some major nostalgia going for it. It doesn’t work well with C code so you need to program it in assembly. There’s a small and fast Arlet Core as well as a Cycle Accurate Core.
  • Esoteric language machines. Because you can.
  • AVR8, an AVR-compatible core.
  • ZipCPU


  • USB Controller. Take the one from the TinyFPGA B-Series repository and implement a host-interface on top of it.
  • UART
  • SPI Master/Slave
  • i2c Master/Slave
  • GPIO
  • Interrupt Controller
  • PWM
  • VGA Controller
  • PS/2 keyboard/mouse port
  • Stepper Motor Controller

Retro Computer Chip Library

There are a lot of retro computers that could be completely implemented on a TinyFPGA B2 board. There could be even more retro computer chips that could be implemented on the TinyFPGA boards that could then be integrated into a physical retro computer.

It would be great to have a library of these legacy components with their original interfaces along with a Wishbone B4 compliant interface. They could be used as a chip substitute in a real retro computer, or combined together to make various retro computers.

Some Retro Chips:

Standalone Microcontroller Peripherals

Sometimes you just don’t have that one chip you need to finish a project. With a TinyFPGA board and the right design, you could just flash the needed component onto the TinyFPGA board and use it without having to wait for another component to be delivered.

There are a lot of peripherals that are pretty standard but would be wonderful to have available at your fingertips when needed. There are also some specialty peripherals that you could base a project around…the kind of things that FPGAs excel at and microcontrollers have a hard time with.

With a standard SPI-Slave to Wishbone master component, these peripherals could be interchangable with the previous ideas.

Peripheral Examples:

  • SPI Chip-Select expander: A SPI device that simply expands the number of available CS pins for the microcontroller.
  • Low-power SPI polling: A SPI device that polls another device on behalf of the host system while the host sleeps. Once the polling condition is met, the host system can be waken up via an interrupt pin. Note that this can be expanded to many interfaces…implement a protocol engine that can wait for a complicated condition using very little power, then wake up the host.
  • Video Adapter: Enable VGA, composite, HDMI, or LVDS video out capabilities for a microcontroller. Text, custom tile, and sprite modes would be great.
  • LCD Adapter: Directly control an LCD panel
  • Stepper/servo Controller: Implement stepper motor control in an FPGA. It could even implement synchronized control of multiple axis to enable high-quality features like true-linear ramp-up and ramp-down that can be difficult to implement fast enough in a microcontroller. Synchronize with many stepper and servo channels.
  • DSP offload: Implement discrete fast fourier transforms, low/high/band-pass filters, and other signal processing in the FPGA to offload the main controller.

and more…

These are some ideas that have been floating in my head. I would love to hear more ideas from the community, projects you want to see, projects you want help on, and anything else that comes to mind.


Turns out I had already put the 6502 microcontroller project on github. If anyone is interested in contributing then be my guest :smile:


The icoSoc project for the icoBoard, by Clifford Wolf, for the icoBoard, satisfies a lot of this requirement. It is based on the picorv32 Risc -V implementation, but is a SoC generator. You write a configuration file to say which modules you want, and each module has a memory-mapped API, You can then write a C program that uses the modules you selected.

I extended this to BlackSoc for the BlackIce II board, This now has a large selection of modules:

  • mod_ad1 : Access to the Digilent AD 1 dual 12-bit, 1MSPS ADC Pmod. This is a variant of mod_spi.
  • mod_adc : Support for the Alinx AN108 AD/DA device.
  • mod_audio : 8-bit audio, uses PWM
  • mod_extirq: Timer and external interrupt support
  • mod_gpio : Access to GPIO pins for input and output.
  • mod_i2c_master : Access to i2c devices.
  • mod_ledpanel: Access to 32x32 and similar LED panels
  • mod_ping: Access to HC-SR04 ultrasonic sensors
  • mod_pmodssd: Access to 7-segment displays
  • mod_ps2: Accessing PS/2 keyboards
  • mod_pullup: A version of mod_gpio with pullup resistors on input
  • mod_pwm : Setting frequency and duty cycles for Pulse Width Modulation signals
  • mod_qspi_slave : A QSPI slave mainly to receive data from the STM32
  • mod_rotary: Access to rotary sensors. Also usable for encoder motors.
  • mod_rs232: Access to uarts
  • mod_spi: SPI master
  • mod_spi_oled: A version of mod_spi for Oled displays
  • mod_tone: Generating audio tones
  • mod_vga_text : Support for text on VGA monitors

I am still learning Verilog and the quality of the modules I have added is nowhere near that of Clifford Wolf’s modules, but they all work to some degree. A version of this could be produced for the TinyFPGA.

It would be particularly suitable for a combination of the EX board and a new version of the retro computer board.


Here is an implementation of Brainfuck for the BX - about as esoteric as they come.

Here is the source -

There are existing implementations in Verilog, but they looked too complicated or not very good, so I implemented my own, as I am practising for implementing more serious soft processors. This implementation executes an instruction every clock cycle, other than (uart) input and output. I haven’t implemented input yet. A simple assembler to produce a hex file is included.


Wow Lawrie - I don’t know where you find the time! :).

You definitely nailed the “esoteric” bit :smile: I guess maybe someone should think about a malbolge interpreter too now? ;-).

Nice work - I really enjoy following your posts to see what’s next :slight_smile:



malbolge is definitely more esoteric.

There is a generator for Brainfuck programs:

For example, a question for @lukevalenty:



This came out a little garbled on the BF interpreter I used, but enough was there for me to figure it out. You’ll have to wait for the Crowd Supply campaign for it, should be launched in the Fall of this year. :smile:


AWESOME! This is a fun language to make implementations for. I had written a simple compiler for BF that performed some simple optimizations. It recognized some common patterns and replaced them with optimized instructions for a BF CPU. I wanted to detect the patterns in the BF CPU itself, but I never got around to it.

If you’re interested in trying it out, this page has some useful patterns and transforms:


Not sure where that got garbled - probably a cut and paste failure. I look forward to the Crowd Supply campaign.


It should have been this: