Free operating systems and microsoft software for linux

J Operating System is primarily intended for programmers.
Target Users:
- Hobbiests--You used to buy computers to do programming. They didnt do much else. Windows doesnt even come with a compiler, which is ironic since Bill Gates wrote BASIC. The "J" operating system is primarily intended for programmers. Ive attempted to lower the bar, so amateurs can contribute. I hope to recreate the dynamic environment that used to exist when the Commodore 64 was around and everyone was creating odd-ball software.
- Researchers--Im sure many lab researchers still use DOS because they have to interact with hardware, which is difficult with Windows.
Main features:
- No security! You can access all ports, memory and disk blocks to your hearts content. When youre working with your own computer, security just gets in the way and makes things slow--I hate anti-virus and anti-spyware because they just slow things down. When you know you dont have a risk, have no secrets and do regular back-ups, who needs security?
- Uniformity
- There is no virtual memory and everyone is on the same address-map. You can easily communicate between tasks, passing addresses. Addresses start at a base of zero and, essentually, segment registers are not used.
- There is basically one language to learn called "C+" which is a little more than "C", but less than "C++". You dont need to learn a scripting langauge because everything uses this syntax.
- There is an extension of ASCII called "J" rich text which allows colors, links, graphics and various widgets in your documents. This format is used in source code, documents, help, menus, etc.
- Support for compressed, encrypted and contiguous files.
- FAT32, FAT12 and ISO9660 filesystems.
- Blazing-fast compiler which can recompile everything in 5 seconds. It doesnt optimize.
- All source code is included and its still around a Meg.
Hardware:
- PS/2 mouse and keyboard
- VGA graphics
- Some hard drives. Must be on the primary or secondary IDE controller and support LBA28. Drives of 120Gig are the limit.
- Some CD-ROM/DVD drives, including burning.
- Some floppies. Just 1.44Meg and not all types.
- No USB support yet
- No network support yet
- ASCII printers on the parallel port are supported.

Inferno is a compact operating system designed for building distributed and networked systems on a wide variety of devices and platforms.
Inferno was originally developed at Bell Labs (the research division of Lucent Technologies).
Inferno Operating System is a well-designed, economical operating system particularly suitable for use in networked devices such as advanced telephones, hand-held devices, TV set-top boxes, and many other embedded applications.
Inferno can run in native mode on an embedded system or in emulation mode under many different operating systems. Inferno has many features in common with Plan 9.
Cross-Platform Portability
Inferno can run as a user application on top of an existing operating system or as a stand alone operating system. Most of the popular operating systems and processor architectures are supported:
Host Operating Systems:
- Windows NT/2000/XP
- Irix
- Linux
- MacOS X
- FreeBSD
- Solaris
- Plan 9
Supported Architectures:
- Intel x86 (386 & higher)
- Intel XScale
- IBM PowerPC
- ARM StrongARM (ARM & Thumb)
- Sun SPARC
Inferno also runs as a plug-in under Internet Explorer version 4 and higher. Each Inferno system presents an identical environment to the applications, irrespective of the underlying host OS or architecture, allowing the developer to work with a truly homogeneous environment across multiple different platforms.
Portable Applications
Inferno applications are written in Limbo, a modern, safe, modular, concurrent programming language with C-like syntax. It is more powerful than C but considerably easier to understand and debug than C++ or Java. Limbo code is compiled into architecture independent byte code which is then interpreted (or compiled on the fly) on the target processor. This means that any Inferno application will run identically on all Inferno platforms.
Transparent Resources
Inferno offers complete transparency of resources and data using a simple but powerful namespace system. By representing resources as files and having one standard communication protocol, resources such as data stores, services and external devices can easily be shared between Inferno systems. A resource interface may be imported to the local system and used by the applications without them knowing, or needing to know, whether it is local or remote.
Security
High level security is an important part of the Inferno system. By using one standard protocol for all network communication, security can be focused on one point and provided at a system level. Inferno offers full support for authenticated, encrypted connections using a certificate based user identification scheme and variety of algorithms including:
- IDEA, 56 bit DES, 40, 128 and 256 bit RC4 encryption algorithms
- MD4, MD5 and SHA secure hash algorithms
A Complete Solution
Inferno is not only an operating system, it is also a complete development environment, providing all the tools necessary for creating, testing and debugging the applications that run within it.
- Acme IDE: includes editor, shell, advanced pattern matching tools & more
- Fast Compiler: with full syntax and compile time type checking
- Graphical Debugger: with full stack trace for currently executing threads
- Powerful Shell: with sophisticated scripting capabilities
- UNIX like commands: including bind, grep, gzip, mount, ps, tar, yacc...
Enhancements:
- New licence terms (a `dual licence scheme allowing use as Free Software)
- Styx revision based on 9P2000, and consequent changes to Sys
- Authentication changes
- Improved colour graphics support, including compositing
- Scalable fonts using Freetype
- Revamped Tk implementation
- Window management moved out of Tk to a separate window manager in Limbo
- Limbo: exception handling and fixed-point
- Limbo: other possible changes
- Dis VM changes
- More commands and library modules
- Better network service configuration
- /net/dns served by host and native DNS resolver
- Hosted kernels configured from a parts list as for native kernels
- Signed modules
- Internet Explorer plug-in revised and in source form
- Expanded documentation

Amiga Research Operating System (AROS) is a portable and free desktop operating system aiming at being compatible with AmigaOS 3.1, while improving on it in many areas. The source code is available under an open source license, which allows anyone to freely improve upon it.

Goals

The goals of the AROS project is it to create an OS which:

1. Is as compatible as possible with AmigaOS 3.1.
2. Can be ported to different kinds of hardware architectures and processors, such as x86, PowerPC, Alpha, Sparc, HPPA and other.
3. Should be binary compatible on Amiga and source compatible on any other hardware.
4. Can run as a standalone version which boots directly from hard disk and as an emulation which opens a window on an existing OS to develop software and run Amiga and native applications at the same time.
5. Improves upon the functionality of AmigaOS.

To reach this goal, we use a number of techniques. First of all, we make heavy use of the Internet. You can participate in our project even if you can write only one single OS function. The most current version of the source is accessible 24 hours per day and patches can be merged into it at any time. A small database with open tasks makes sure work is not duplicated.

History

Some time back in the year 1993, the situation for the Amiga looked somewhat worse than usual and some Amiga fans got together and discussed what should be done to increase the acceptance of our beloved machine. Immediately the main reason for the missing success of the Amiga became clear: it was propagation, or rather the lack thereof. The Amiga should get a more widespread basis to make it more attractive for everyone to use and to develop for. So plans were made to reach this goal. One of the plans was to fix the bugs of the AmigaOS, another was to make it an modern operating system. The AOS project was born.

But exactly what was a bug? And how should the bugs be fixed? What are the features a so-called modern OS must have? And how should they be implemented into the AmigaOS?

Two years later, people were still arguing about this and not even one line of code had been written (or at least no one had ever seen that code). Discussions were still of the pattern where someone stated that "we must have ..." and someone answered "read the old mails" or "this is impossible to do, because ..." which was shortly followed by "youre wrong because ..." and so on.

In the winter of 1995, Aaron Digulla got fed up with this situation and posted an RFC (request for comments) to the AOS mailing list in which I asked what the minimal common ground might be. Several options were given and the conclusion was that almost everyone would like to see an open OS which is compatible to AmigaOS 3.1 (kickstart 40.68) on which further discussions could be based upon to see what is possible and what is not.

So the work began and AROS was born.

Habitat from System Garden is a performance monitor of applications and operating system with the ability to track availability and service level. System Garden Habitats design goals are to be of modest size, flexible and ubiquitous.

The core of habitat provides a mechanism for collecting, storing and distributing data. Out of the box are many useful system collectors, known as probes.

Additionally, there is an API available to extend the collector (known as clockwork) with plug-ins, which allows data to be pulled from applications. Another API and a command line interface lets applications and scripts of all types push information into the collection system.

RT-Thread is a real-time operating system. It is designed specifically for small memory footprint platforms. The kernel supports the tranditional RTOS services, such as multiple threads, semaphores, mutexes, event flags, mailboxes, etc.
RT-Thread project also provides a C-expression interpreter shell, from which a programmer can access kernel variables and invoke system functions.
Main features:
Kernel Object System
- There is a kernel object system, which can access and manage all of the kernel objects. Kernel objects include most of the facilities in the kernel, for example, thread, semaphore etc. Kernel objects can be static objects, whose memory is allocated in compiling. It can be dynamic objects as well, whose memory is allocated from system heaps in runtime. Through the kernel object system, RT-Thread operating system can be independent from the memory management system and greatly enhance the scalability of the system.
Multi-Task/Thread Scheduling
- RT-Thread operating system supports multi-task systems, which are based on thread scheduling. The scheduling algorithm used in RT-Thread operating system is a full preemptive priority-based scheduling algorithm. It supports 256 priority levels, in which 0 is the highest and 255 the lowest. The 255th priority is used for idle thread. The scheduling algorithm also supports threads running at same priority level. The shared time-slice round-robin scheduling is used for this case. The time of scheduler to determine the next highest ready thread is determinant. The number of threads in the system is unlimited, only related with RAM.
Synchronization Mechanisms
- RT-Thread operating system supports the traditional semaphore and mutex. Mutex objects use inherited priority to prevent priority reversion. The semaphore release action is safe for interrupt service routine. Moreover, the block queue for thread to obtain semaphore or mutex can be sorted by priority or FIFO.
Inter-Thread Communication
- RT-Thread operating systems supports event/fast event, mail box and message queue. The event mechanism is used to awake a thead by setting one or more corresponding bit of a binary number when an event ocurs. The fast event supports event thread queue. Once a one bit event occurs, the corresponding blocked thread can be found out timing accurately, then will be waked up. In mailbox, a mail length is fixed to 4 byte, which is more effective than message queue. The send action for communication facilities is also safe for interrupt service routine.
Clock and Timer
- In default, the system uses clock tick to implement shared time-slice scheduling. The timing sensitivity of thread is implemented by timers. The timer can be set as one-shot or periodic timeout.
Memory Management
- RT-Thread operating system supports two types memory management: static memory pool management and dynamic memory heap management. The time to allocate a memory block from the memory pool is determinant and when the memory pool is empty, the allocated thread can be blocked (or immediately return, or waiting for sometime to return, which are determined by a timeout parameter). When other thread releases memory blocks to this memory pool, the blocked thread is wake up.
Enhancements:
- More porting was done to Samsung S3C44b0 CPU, AMTEL AT91SAM7S64, Nintendo DS, and Intel i386.

Core is a minimal distribution of the GNU/Linux operating system designed to be the basis for a complete system constructed by the end user. A fresh installation of Core will boot into a console and provide the user with the tools needed to download, compile and install other applications. Core contains nothing beyond what is required to perform these tasks.
Core is primarily designed for experienced Linux users, though it has found an audience with those looking to learn about the internals and operation of a Linux system. Core requires the user to manually configure, compile and install applications and expects the user to consult man pages and other documentation.
Installation:
These instructions are incomplete, but should be sufficient:
- Download, burn and boot the ISO.
- Partition, format and mount the hard drive.
- Run install_core [mount point of hard drive].
- Optional packages in /pkgs/optional can be installed with corepkg(8).
- Copy the kernel from /pkgs/kernel to /usr/src of the hard drive.
- Run chroot [mount point] bash -l to chroot into the new system.
- Compile and install the Linux kernel [be sure to run LILO].
- Review and modify the files under /etc.
- Reboot and start constructing the new system.
MD5 sum: 5da52af0d4b0a599cc119afcace77c9c

File System development is very difficult and time consuming. Even small changes to existing file systems require deep understanding of kernel internals, making the barrier to entry for new developers high.

Moreover, porting file system code from one operating system to another is almost as difficult as the first port. Past proposals to provide extensible (stackable) file system interfaces would have simplified the development of new file systems.

These proposals, however, advocated massive changes to existing operating system interfaces and existing file systems; operating system vendors and maintainers resist making any large changes to their kernels because of stability and performance concerns. As a result, file system development is still a difficult, long, and non-portable process.

The FiST (File System Translator) system combines two methods to solve the above problems in a novel way: a set of stackable file system templates for each operating system, and a high-level language that can describe stackable file systems in a cross-platform portable fashion.

Using FiST, stackable file systems need only be described once. FiSTs code generation tool, fistgen, compiles a single file system description into loadable kernel modules for several operating systems (currently Solaris, Linux, and FreeBSD).

The project demonstrates that with FiST, code size and development time are reduced significantly, while imposing a small performance overhead of only 1-2%. These benefits are achieved, as well as portability, without changing existing operating systems or file system.