Free mips software for linux

RTEMS (Real-Time Executive for Multiprocessor Systems) is a commercial grade real-time operating system designed for deeply embedded systems. The project is a free (as in beer and speech) open-source solution that supports multi-processor systems.
RTEMS is designed to support applications with the most stringent real-time requirements while being compatable with open standards such as POSIX. Its been ported to over ten processor architectures including ARM, PowerPC, i386, M68K, Coldfire, MIPS, SPARC, SH, H8, and C3x/C4x DSPs.
Using the GNU tools for cross development, you can use any number of systems as development hosts including both Unix and Windows platforms.
Main features:
- realtime system design
- semantics of BSP building and maintenance
- driver development for clock, timer and RTC drivers
- console drivers for raw and termios mode
- network drivers
- BSP structure
- handling of target depenencies
- Classic API
- POSIX API
Enhancements:
- This is the first snapshot from the CVS head since the 4.7 release branch was made.
- It adds POSIX barriers, spinlocks, rwlocks, and Classic API Barriers.
- It adds a new port to the Altera NIOS II.
- There is also the usual assortment of cleanup and name changes to increase adherance to coding conventions.

MediaTomb is a UPnP media server with a nice Web user interface. The project allows you to stream your digital media through your home network and play it on a variety of UPnP compatible devices.
MediaTomb implements the UPnP MediaServer 1.0 specification. The current implementation focuses on parts that are required by the specification. MediaTomb should work with any UPnP compliant MediaRenderer.
Main features:
- browse and playback your media via UPnP
- metadata extraction from mp3, ogg, flac, jpeg, etc. files.
- Exif thumbnail support
- user defined server layout based on extracted metadata (scriptable virtual containers)
- automatic directory rescans
- sophisticated web UI with a tree view of the database and the file system, allowing to add/remove/edit/browse your media
- support for external URLs (create links to internet content and serve them via UPnP to your renderer)
- support for ContentDirectoryService container updates
- Active Items (experimental feature), allows execution of server side scripts upon HTTP GET requests to certain items
- highly flexible configuration, allowing you to control the behavior of various features of the server
- support for Linux, FreeBSD, Mac OS X
- runs on x86, Alpha, ARM, MIPS, Sparc
Enhancements:
- This release introduces two new features: playlist support and inotify autoscan mode.
- As always, there are also some bugfixes and further improvements like album art support.

XORP is the eXtensible Open Router Platform, an open- source router software stack.
The goal is to develop a software router platform that is stable and fully featured enough for production use, and flexible and extensible enough to enable network research.
XORP project implements routing protocols for IPv4 and IPv6 and a unified means to configure them.
Enhancements:
- This release implements OSPFv3 (draft-ietf-ospf-ospfv3-update-14.txt).
- It also contains numerous bugfixes and cross-compilation support for various processors: IA-64, MIPS (Broadcom for Linksys WRT54G), PowerPC-603, Sparc64, and XScale. The new supported systems are: DragonFlyBSD 1.8, FreeBSD 6.2, Linux Fedora Core6, Linux Debian 3.1 (sarge), NetBSD 3.1, and OpenBSD 4.0.

Yet Another Machine Simulator is a machine simulator which emulates the MIPS32 architecture CPU close enough. Should be fully compliant, but we cant claim that it is. It allows cross compilation with standard MIPS32 compiler back-ends.
YAMS also provides a very simple device interface to the simulated memory, disks, network interfaces, terminals and a real-time clock. There is also support for pluggable I/O devices. Pluggable devices are separate programs that implement the functionality of one or more devices and communicate with YAMS over a network or Unix domain socket.
Many features of YAMS are configurable. For example the number of CPUs can be configured. When the number of CPUs is more than one, YAMS simulates an SMP machine. The devices are also configurable. For example various delays for disks, terminals and network interfaces can be set.
YAMS also provides a hardware console which can be used to debug programs. The hardware console can be used to set breakpoints and dump the contents of registers, TLBs and memory. The memory dumping functionality also contains a disassembler.
Performanc:
The purpose of YAMS is to provide a very simple yet realistic simulated hardware platform for educational purposes. High performace (i.e. high clock speed) was not a factor in its implementation, so a normal slowdown factor between host clock speed and simulator clock speed is in the order of 500, resulting in simulator clock speeds of only a few megaherz.
So if you are looking for a fast MIPS emulator/simulator, then YAMS is not for you.
Enhancements:
- Better portability with pthreads and printf formatting macros.
- Minor bugfixes.

KMD is a graphical debugger written by me for The University of Manchester Computer Science Department.

It can debug hardware over serial ports such as the Manchester ARM Board or with software emulators (ARM and MIPS emulators are included in the project). Using the pipe option you can debug over the network or any other communication medium.

It can load many executable formats such as ELF and display and follow the original source even from multiple source file programs. There is support for breakpoints and watchpoints which can trap specific instructions (such as loading or executing specific instructions).

Support for other features such as FPGAs is also available, allowing loading or any control required to drive a specific hardware device. The project uses chump to allow disassembly and line assembly.

Chump also allows new architectures to be easily added without the need to recompile the system. Communication with the backend is done using two pipes/fifos using a simple set of codes. Back end communication program can be created using very little memory on the target device.

Compile:

Download the latest version of KMD. unzip the archive with

tar zxf KMD-latest.tar.gz

Enter the KMD directory

cd KMD-0.9.??

Run the configure script

./configure

Run make

make

Run
The compiled programs should be in the src directory

cd src

Run KMD and specify that you are running with the defauit configuration file (-i)
and using an emulator called jimulator which is an ARM emulator (-e ./jimulator)

./kmd -i -e ./jimulator

KMD requires the following libraries:

- GLib - Provides many useful data types, macros, type conversions, string utilities and a lexical scanner.
- GDK - A wrapper for low-level windowing functions.
- GTK - An advanced widget set.
- BFD - the Binary File Descriptor Library. (BFD comes with GCC or binutils)
libiberty - The libiberty library is a collection of subroutines used by various GNU programs. (also comes with GCC or binutils)

GXemul is a machine emulator Im developing in my spare time.
GXemul project emulates processors and surrounding hardware components, in some cases well enough to allow unmodified "guest" operating systems to run inside the emulator as if they were running on a real machine.
MIPS:
- Several machine types are emulated well enough to run guest operating systems. NetBSD, OpenBSD, Linux, and even obscure things such as Ultrix and Sprite can run, to various degrees.
ARM:
- CATS is emulated well enough to run NetBSD and OpenBSD as guest OSes.
PowerPC:
- NetBSD/prep can run (experimental).
The emulator can be used for:
- experimenting with operating systems which you have not tried yet, or operating systems for hardware which you might not have access to,
- running guest operating systems for historical purposes, e.g. Ultrix or Sprite,
developing portable software, when you want yet another target platform to try to compile your software on (you can use GXemul to run a guest OS and compile your software inside that OS),
- development of new firmware or operating system code (but then you need to be aware of some limitations),
- educational purposes...
Enhancements:
- NetBSD/pmppc can now run in the emulator (with root on NFS).
- For ARM emulation (with NetBSD/cats, OpenBSD/cats, NetBSD/evbarm, or NetBSD/netwinder as the guest OS), the emulator does not use 100% of the hosts CPU if the guest OS is idle.

CHICKEN is a compiler for the Scheme programming language. CHICKEN produces portable, efficient C, supports almost all of the current Scheme language standard, the Revised5 Report on the Algorithmic Language Scheme (R5RS ), and includes many enhancements and extensions. CHICKEN runs on MacOS X, Windows, and many Unix flavours.
Main features:
- Compiles Scheme to efficient and portable C
- Includes a full-featured interactive interpreter as well as an optimising batch compiler
- Full support for tail recursion, first-class continuations, high-level macros and dynamic-wind
- Highly portable and known to run on many platforms, including IA-32 (80x86), IA-64, PowerPC, SPARC and UltraSPARC, Alpha, MIPS, PA-RISC, ARM, AMD64 and S/390
- Distributed free for use and modification under the terms of the BSD License
- Transparent support for shared objects and linkage to C
- A sophisticated but easy-to-use Foreign Function Interface for linking C and C++ libraries and classes to Scheme
- Lightweight threads based on first-class continuations
- An object system with multiple dispatch, multiple inheritance and a meta-object protocol
- Common Lisp-style format
- Provides the syntax-case enhanced high-level macro system, R5RS syntax-rules , and define-macro
- Support for syntactic pattern-matching via Andrew Wrights match package
- Execution profiling, debugging and backtrace support
- A clean POSIX interface that covers environment and filesystem access, pipes, processes, signals, locks, sockets, and low-level and memory-mapped I/O
- Support for interpreted or compiled shell scripts under Unix and Windows
- Support for a large number of Scheme Requests For Implementation (SRFIs), some available separately as extensions:
SRFI 0 (cond-expand )
SRFI 1 (List library)
SRFI 2 (and-let* )
SRFI 4 (Homogeneous numeric vector datatypes)
SRFI 6 (Basic string ports)
SRFI 8 (receive )
SRFI 9 (Record types)
SRFI 10 (#, external form)
SRFI 13 (String library)
SRFI 14 (Character set library)
SRFI 16 (case-lambda )
SRFI 17 (Generalized set! )
SRFI 18 (Multithreading support)
SRFI 23 (error )
SRFI 25 (Multidimensional array primitives)
SRFI 26 (cut , cute )
SRFI 28 (format )
SRFI 30 (Block comments)
SRFI 37 (Program argument processor)
SRFI 38 (External representation for data with shared structure)
SRFI 39 (Parameters)
SRFI 40 (Stream library)
SRFI 42 (Eager comprehensions)
SRFI 43 (Vector library)
SRFI 55 (require-extension )
Version restrictions:
- No unlimited-precision integers (bignums), rationals or complex numbers
- Procedures are limited to 126 arguments
- No support for unicode
- Compilation of large files can be slow
Enhancements:
- chicken-setup: better handling when no remote repository file exists