JOSE - Jay's Operating System Experimental
JOSE is a hobby project that I am currently working on. It is a
32 bit operating system that is very slowly progressing. Eventually,
it will have the ability to be multitasking and handle all of the
interrupts, memory, etc.
The OS is built now using GCC and Linux. The OS is placed onto a
1.44 MB floppy and is made so that it is bootable.
Here is the history of JOSE as it currently stands and what each version
is for. As of this writing, 0.0.9 is the current version.
- Version 0.0.9
All 256 interrupts being captured and counted. The text screen gets
filled with hex numbers -- they represent the number of interrupts counted
for a particular interrupt number. Nothing useful here.
- Version 0.0.8
This version prints up a nice ASCII and attribute chart onto the
screen. These charts are kinda nice but otherwise it is not very useful.
Interrupts were successfully enabled without the machine rebooting.
- Version 0.0.7
I got tired of building JOSE using a bunch of helter-skelter methods in
MS-DOS. This is the first version built in GCC in Linux and I am quite
glad I made the move for now it is much easier and faster to build a boot
- Version 0.0.6
This version (quickly) scans memory for bad spots. I used this to
determine if I had some bad RAM on a machine.
- Version 0.0.5
This version was a simple demonstration that Pascal files compiled with
Borland's Delphi could be linked in and be used -- they can.
- Version 0.0.4
This version was a simple demonstration that C could be linked with the
assembly code to produce a program. They can. Borland C++ 4.5 is used
to compile the C code. Why? I wanted the tools that build JOSE
to be run from straight MS-DOS. Borland C++ 4.5 has a Command-Line
based compiler which runs under 16 bit MS-DOS but produces 32 bit code.
- Version 0.0.3
This version demonstrated that 32 bit protected mode could be achieved.
There is no C code here. All of it is in assembly (almost has to
because we need low-level access to hardware). This also shows that
the second phase boot code can load up the rest of OS
from the floppy,
go to 32 bit protected mode, and run the OS.
- Version 0.0.2
This version does not even get to 32 bit protected mode. It
shows that the second phase of the boot process on the floppy can be
achieved. The first phase (done in version 0.0.1) simply is the loading
of the first sector of the floppy and that the code gets executed.
This version demonstrates that the first phase can load in more sectors
off of the disk and that the second phase code can be executed.
- Version 0.0.1
A simple boot floppy. Only contains one sector of data -- that first
sector on the disk that gets read in by the BIOS on boot up. This
code gets run and puts up some kind of "Hello World" message on the
screen. The Borland Assembler is used to assemble the code and a
special program built to strip the resulting EXE file and make it into a
single sector that will be booted.