ForwardCom is a new open instruction set architecture and complete set of standards and tools for an efficient open source computer.

The ForwardCom project is an attempt to explore what an ideal computer system may look like. Starting from scratch and making a complete vertical redesign of hardware and software allows us to learn from the history of past mistakes and get rid of the heritage of old quirks that hamper contemporary systems.

The main advantage of other open instruction sets, such as OpenRISC and RISC-V, is that they are free and open. ForwardCom takes the idea of openness further and strives to make an open system that is more efficient than the proprietary instruction sets, such as x86, ARM, etc.

The ForwardCom instruction set is neither RISC nor CISC, but a new design that combines the efficient decoding and pipeline structure of RISC systems with the more work done per instruction of CISC systems. ForwardCom has few instructions but many variants of each instruction. All instruction codes fit into a standardized template system that makes both hardware and software more efficient.

Vector support is a fundamental part of the design rather than a clumsy appendix. ForwardCom has variable-length vector registers. Each hardware implementation can have a different maximum vector length. The instruction set is designed so that an array loop will automatically use the maximum vector length of the microprocessor it is running on. If a new hardware version with longer vector registers becomes available, then the existing software will run optimally on the longer vectors without recompilation. Compiled software will always be compatible with future hardware versions without recompilation. This is forward compatibility. ForwardCom stands for forward compatible computer system.

The instruction set is fully orthogonal. The same instruction can be coded with integer operands of different sizes and floating point operands of different precisions. The operands can be scalars or vectors of any length. Operands can be registers, memory operands with different addressing modes, or immediate constants.

All code is position-independent. Memory management is simpler and more efficient than in traditional systems. Various techniques are used for avoiding memory fragmentation. This may eliminate the need for memory paging and translation lookaside buffer.

Standards for software tools, calling conventions, ABI, file formats, system libraries, etc. are defined in order to establish compatibility between different programming languages and different platforms. It will be possible to code different parts of a program in different programming languages.

There are no dynamic link libraries or shared objects. Instead, there is only one type of function libraries that can be used for both static and dynamic linking. The library code is kept contiguous with the main program code in almost all cases. An executable file can be re-linked to update a function library or to adapt the program to a particular hardware configuration, operating system, or user interface framework.

Strong security features are included in the design.

The assembly language syntax looks like high-level code which makes it easy to use and understand.


Vision
ForwardCom will not readily replace the commercial systems, even if it is better, because the users need compatibility with existing hardware and software. However, the development of an ideal instruction set architecture and a complete redesign of the ecosystem of hardware and software standards is a worthwhile exercise in itself which may produce useful results and unexpected new discoveries. This project has already generated so many valuable ideas that it is worth pursuing further.

ForwardCom may be useful for purposes such as:
* FPGA soft cores
* System on a chip designs
* Supercomputers with very long vector registers
* Applications where the patent and license restrictions of other architectures would be an obstacle
* Applications where the security features of ForwardCom are needed
* Niche products where compatibility with older systems is not required
* Real-time systems where the efficient memory management and fast task switching of ForwardCom is useful
* Applications that need application-specific instruction set extensions
* University projects and experiments with new ideas
* Some of the new ideas generated by the ForwardCom project may be applied to other systems


Status of the project

* Instruction set, ABI, and other standards are defined
* Development tools are available, including assembler, disassembler, linker, library manager, emulator, debugger, etc. (C++, GPL). A compiler is not available yet.
* A softcore is available. 6 stage pipeline. One instruction per clock cycle. All integer instructions are supported, except multiplication, division, push, pop. Vector instructions and floating point instructions not supported yet. (System Verilog, CERN-W license).
* A test suite for self-test is provided


Resources

Website https://www.forwardcom.info

Discussion forum: https://www.forwardcom.info/forum

Manual: https://opencores.org/ocsvn/forwardcom/forwardcom/manual/forwardcom.pdf

OpenCores project and repository: https://opencores.org/projects/forwardcom

Github mirror: https://github.com/ForwardCom



Community
Agner Fog is the main developer of ForwardCom. Other people are welcome to contribute. University projects are welcome.