SquirrelJME is an idea and execution that extends from previous ideas and projects. The base idea extends from my desire to write an operating system to run on systems, since such things have fascinated me.

Old Projects (2011/01/15 - 2016/02/25)

These are old defunct projects which I have previously worked on.

I will say that it can take years before you can find a project you enjoy working on and one that inspires you. Keep searching. Just be careful where you step and do not take in more than you can handle.

HandOS (2011/01/15 - 2011/01/22)

This was an attempt at creating an open source implementation of Palm OS. Palm OS was not actively used much often and additionally existing emulators for Palm OS are sub-par in that they were either old or were horribly out of date. The goal of the project was to run m68k and ARM Palm OS applications on the host system.

The project was fully structured and had all the default applications in place as placeholders for when they were ready.

However, the project could not actually be compiled, it was mostly pretty much just placeholders, some reference documentation, and notes. It did include some tests which showed that threading was indeed possible on Palm OS like modern systems.

MPA Orange-Sapphire (2011/12/12 - 2011/12/13)

This was a very short project which never really took off. It was intended to be an operating system written in a BASIC-like language. Obviously BASIC is rather horrible compared to the languages of today.

MPAYAOS (2012/02/20 - 2012/02/29)

Standing for Yet Another Operating System.

This was a short attempt at another operating system, it never really got past the bootloader stage. It was written in C.

HandNIX (2012/05/28 - 2012/05/29)

Standing for Hand UNIX Environment.

This was an attempt to make a UNIX-like environment for Palm OS so that I could do development for my projects on Palm OS. It existed as a single C source code file.

Only a few things were implemented. The major thing which was implemented was a basic cooperative tasked system which was based on Palm OS's versions of setjmp and longjmp. There also was a basic terminal emulator which did not support any escape sequences.

Every POSIX command that existed on the system was referenced via a function pointer and the intention was to have virtual files (via #!) which would execute those internal commands when requested. The environment would have started on the shell (sh) which would then be available to execute other programs.

HandOS 6.3 (2012/05/31 - 2012/08/17)

HandOS is a clone of Palm OS, however the main purpose of this project was to implement the only released in a simulated environment: Palm OS Cobalt.

It was written in C and it required the Palm OS SDK for compilation.

I did not have headers for Palm OS 6, so I was writing the headers from scratch.

MPAPCOS (2012/09/30 - 2013/01/16)

Standing for Posix Compatible Operating System.

This was an attempt to write an operating system which was compatible with POSIX:2008 and could run such programs. A C preprocessor was written and some basic utilities were supported, but generally that was as far as it got.

HandOS 5.6 (2013/01/23 - 2013/02/05)

This was another attempt at writing a Palm OS clone, it did not get very far. There was basic project structure but not much else.

MPAMSEK (2013/03/31 - 2013/04/14)

Standing for Multi-System Emulation Kernel.

This project was I believe to write an operating system which could run many other operating systems in a very bare bones emulated environment to run as if it were on native hardware. Basically, you would boot into a system and instead of running an OS with an emulator running on it, the emulator would be directly running on the hardware.

I only really got a basic system launch on PowerPC's Open Firmware. I was able to print to the system's framebuffer console but not much else.

MPAOSKP (2013/04/14 - 2013/05/15)

This project is based off MPAMSEK.

I am not too sure what the acronym stood for, very likely it stood for Operating System Kernel Project.

I wrote a memory allocator but it never really got past the boot loader and early kernel initialization stages.

PowerPC and x86 worked on Open Firmware.

I failed to get SPARC working, I could just not get the bootloader to run properly and it usually ended up just crashing or not working at all. It may have been related to register windows.

I thought about writing a C compiler but I gave up quickly and abandoned that idea because that would be too much work with too little of a benefit.

POSIX Environment for Palm OS (2013/07/25 - 2013/07/27)

This project was essentially similar to an earlier but was a POSIX environment for Palm OS. By reverse engineering bits of Palm OS previously I determined that some things were very possible. For Palm OS 5 I had pretty much a concept background threading and server system. Basically a daemon would be launched in the background which would keep the environment running. There would be a connection made to the daemon with locks and semaphores. There would then be a terminal interface which would show what was being output to the console.

There would be threads in the background running tasks. However to access the server process a pointer would have to be remembered. This is where the feature manager was used to keep a persistent handle in memory so the daemon could be connected to. I determined that it was very important to be able to switch programs outside of the environment.

For SquirrelJME on Palm OS, I have an idea to do something very similar so that it runs in the background while other applications may be used.

POSIX Environment for Palm OS (2014/10/12 - 2014/10/12)

This project never went past a few files and headers. The purpose of this project was the same as the previous.

k5 (2013/12/25 - 2014/04/25)

This project had 503 commits.

This is basically the start of my delving into Java virtual machines. It was written in Java and was pretty bloated when it came to the compiler, using very abstract concepts for compilation. It was to target Java SE but I am not too sure which version it was for. Very likely it was Java 7 as Java 8 was released shortly before this project ended.

I never really got past the JIT stage in the project. It was also quite massive of a project.

Anything that was made for documentation was written in LaTeX, which is far less friendly compared to Markdown.

k8/Squirrnix (2014/04/26 - 2016/02/25)

This is the direct predecessor to SquirrelJME. Utilities and classes in SquirrelJME have been derived from this project. Generally if I find a class which is missing in SquirrelJME I check this project and copy all of the code from there since the bulk of it is just placeholder.

This project had a massive number of commits: 9041.

It intended to implement the entirety of Java SE 8 with all of its profiles. This was for the most part a very unrealistic goal. As with k5, it never really got past the JIT stage. The massive requirements in place were unrealistic. This project was doomed for failure even when it began but I was a bit foolish to take up this task.


Starting Background

SquirrelJME stems from the following ideas:

I had a growing fascination with J2ME. I had an old cell phone which could run J2ME applications. I would make a few concept projects but they did not last long because programming for J2ME is quite horrible as it is very lacking when it comes to Java. I did have the idea of writing a virtual machine that could run J2ME applications so that I could use some again.

Another thing is that the write once and run anywhere aspect of Java pretty much fascinated me also. The idea of writing a program once and having it work pretty much everywhere was indeed interesting. I wanted to do this with k8 but it was not really a feasible thing to do because it was so gigantic.

However, there was much frustration with my then current project k8. It was gigantic and the number of classes to implement was essentially an impossible mountain to cross. There was a growing sense of doubt that the project would never get anywhere because it had unrealistic goals that would be impossible for a single woman to obtain all by herself. I calculated that it could take perhaps up to a decade to implement the core classes of Java SE 8. By a decade's time, Java SE 8 would be obsolete and nobody would be using it anyway. So this compounded a wasted effort. Additionally being a third-party VM, there would quite literally be very little interest in it, so it could not be for fame. Basically it was too much and too ambitious of a project and sadly it took two years to realize that.

Near the end of the project's life span I was a very depressed person, I felt like the project was a complete waste of time and that life was rather meaningless. I felt trapped working on the project with no escape. My life was melting away into nothingness and worthlessness. I did not want to admit that the project was a failure and would be going nowhere, I was naive.

In February of 2016 I watched Hack Summit 2016, it was pretty much the first online conference which I have visited. It was really exciting and it did move me a bit. But I think the one talk which really moved me was the one by Sarah Allen (you can see her on YouTube here: https://www.youtube.com/watch?v=S1iYeThQO-g). It really resonated with me and it has really given me the light shining through my own fog to realize that my own project was ruining my life. After that I decided that my own project was not something I really wanted to do, that my ambitious goals were not even caring for myself. I decided that I should care more about myself and that I had to cut my project loose.

When that happened, I was still so very much interested in Java and having write once and run anywhere, portability and virtual machines. I found Java to be very awesome. I knew that k8 would never fit on the systems I would have liked to target. I got the motivation to push Java as small as it can go. I knew the gigantic size of k8 was too much, so I decided to switch to the small scale. I remember my fascination with J2ME and I wanted to clone that environment because I found it interesting. Java was seen as this gigantic bloated monster that ate so much CPU and so much memory. But working with the JVM so much made me realize how wrong it was. Java was in fact very small and very light. J2ME was very light and very simplistic.

The first thing to do is determine has J2ME been updated ever? To my surprise it actually was updated for Java 8. So this was quite something. Although it was not really a microscopic Java 8 VM it was Java 7, which was good enough. It added extra classes and was in general quite cool. JSR360, which is the specification for Java ME 8 was proposed on October 2, 2012. The final release was made on April 30, 2014. Java SE 8 being released on March 18, 2014. So Java ME 8 came out very shortly after Java SE 8. However with Android and iOS being everywhere it never really stood a chance and Java ME 8 never really got the chance to actually be anything.

I decided to study Java ME 8, to see if it was indeed viable. I took a quick glance at it and then deeper dives into it. Java ME 8 imported quite a number of things from Java SE 7. It basically was bringing it up to date with the modern Java language rather than languishing in the past. It did remove some things but, in the essence of compatibility those could still be brought in. These removed things were stuff such as LCDUI, which were pretty much nowhere. It took a bit to verify compatibility but the changes made do not have an impact on backwards compatibility. As such this was a bonus.

One added bonus that I liked is that Java ME was so small compared to Java SE. It is very tiny and extremely compact. Basically what is in the language is the bare minimum sane choice. I will say that there are some errors and perhaps some omissions but in general it has been rather good. The thought of Java SE being implemented and the gigantic task I knew was impossible and the small size of Java ME is actually is within reach. The small number of classes, up around 512 classes for the standard makes it very reasonable. This estimated 512 classes is about half the size of Java SE 8's compact1 and does not include things such as SQL. I really liked the fact that it gave you the minimum set of classes and you could just bring your own classes in if you care about it. Personally, I do not really care for SQL and stuff like CORBA because I do not often use them at all.

Naming and Mascot

The name SquirrelJME comes from the fact that I personally find squirrels to be very interesting and curious animals, not to mention that they are cute. Where I used to live I would see squirrels all the time so they were quite common, although where I live currently as of this writing I do not often see squirrels.

Originally my plan for a mascot at least for k5 or k8 would be to have a pink bunny rabbit in reference to The Legend of Zelda: A Link To The Past. In this game there is a region that you can enter called the Dark World where every human who enters is transformed into an animal that reflects their inner self. I then switched my idea to having the mascot be albino because these animals are a bit more rare (since they are more easily predated in nature because their bright white fur stands out). Then when SquirrelJME has come around I decided to keep the same mascot but make him a squirrel instead. So the green tunic that Link wears is a reference to the Zelda series.

It was difficult finding a name for him, as such I initially decided on just placeholder name for awhile. I thought about Lexer but that was quite long and slightly complicated, so I shorted it to Lex. It was nice and for the most part the name stuck since I was happy with it. Therefor it was never changed.

He was uploaded on 2016/05/07 to the repository.

He has subsequently been redrawn on 2018/10/19 by Kat Adam-MacEwen, where he ended up very handsome. She is quite a wonderful artist.

The C based virtual machine RatufaCoat was named by meepingsnesroms of the Mu project. Ratufa being the sub-species of squirrels in southeast Asia.

Gaining a Sister Project

On 2018/11/03 the developer of Mu, meepingsnesroms, wanted to become a sister project of SquirrelJME, so this was very exciting! The link to her repository is in the readme! We will be cooperating mostly by word of mouth by linking to each other's projects to hopefully gain interest in both of our projects.

The First Release

The first version of SquirrelJME was released along with Mu on December 25, 2018. The repository had 10,571 commits.

This release was mostly just a demo to show that SquirrelJME exists and that it is being worked on. It is very primitive and not much can be done with it. From the release though there has been slowly increasing interest in the project since there are not many emulators that support J2ME that exist and are actively worked on.

The Second Release

To be written...