I tested my Forth implementation a bit, and found some bugs, now fixed. But it will need some more testing.

I also realized that not implementing the double-precision words wasn't a good idea. So I wrote them, in hi-level Forth. I just had to add another instruction to my instruction set, but now my MUL instruction is not needed any more, so I removed it. It will make the hardware design easier to do, so hopefully it will be ready sooner. Good.

I also fixed the drawing routine of the applet, that was not called when needed, leaving sometimes an empty black screen.

Feel free to test the updated Java applet.

Here it is ! My Forth implementation is rather close to the end (as well as the instruction set for the CPU).

It is based on Bradford J Rodriguez's CamelForth for the Z80, so I called it PandaForth (don't ask why).

You can test it with this Java Applet.

Yes, it is written in Java, but don't be confused. It is not a Forth-in-Java implementation. Here, Java is used as an emulator for the processor, and as a macro assembler, so it is in fact a Forth written in assembly.
Fell free to test the applet, and drop me an message if you find some bugs :)

Like CamelForth, it is a 16-bits Direct-Threaded-Code implementation. All CPU opcodes are 8-bits, and the instruction set is the one of a "pure" stack-based processor.

Here are the main differences with CamelForth :

• Low-level routines have (of course) been rewritten.
• Parameter and Return stacks are internal, so Forth words dealing with them have been rewritten.
  
• All double-precision and division/modulo words have not been ported. Only two operations are implemented : * (signed 16b/16b multiplication) and U/MOD (unsigned 16b/16b division and modulo).
  
• Words dealing with numeric input/output using double precision have been rewritten to use single-precision instead.
  

The main reason why I didn't code all the arithmetic stuff is that this Forth implementation is temporary. As I will probably use the two banks of 16-bits RAM, I think the Forth implementation will become a 32-bit Subroutine-Threaded-Code one.

But this will be done later. I think I have spent enough time on Forth for the moment, and I'd like to make a break, by getting back "close to the metal" and start designing the CPU.

Here is a J2ME version of my GBA puzzle-game Pnakys. Compared to the GBA version, this one features :


- Professional-quality graphics
- Revamped gameplay
- Different game modes
- Opponents with special attacks
- Difficulty levels
- Hi-score tables
- Items to unlock...



I collaborated on this project with Dalk, a professional pixel artist, who did the graphics and the game design.

Here is a demo version (.jar file) (.jad file) you can download. More details about the commercial version will be available later.

Here is the list of compatible phones. If your phone is not in the list, please try the demo version on your phone and tell me if it works. For each phone model, the first person sending me a picture of the demo running on hardware will get a commercial version for free.

Pnakys has been reported to work succesfully on :

• Sony Ericsson T610
• Nokia N-Gage
• Nokia N-Gage QD
• Motorola Razr (Razor) V3

I have added a new section about Mobile Phones, in which you can find a brand new item : Pnakys J2ME Demo Version.

In the FPGA Section (the most active at the moment) you will find another thing you can play with : a Java applet emulating my future processor, running a Forth implementation I have called PandaForth.

Well, it's been some time now since my last update.
I've been pretty busy with my job, but I will have more available time now...
I discussed with a guy that pointed me out this nice LCD display (Sony Color LCD Module ACX705AK), available at the Electronic Goldmine. Wow, cheap and sexy :) It made me think about what could be the next version of my homebrew console : a homebrew handheld :)

But for the moment, I need to focus on my CPU design. Both CPU instruction set and Forth implementation are getting more and more advanced, and I expect to have them finished not too late. The instruction set has finally turned into the one of a pure Stack-based processor, and I'm more comfortable with Forth now. I'll probably make a Java applet to show what have been done, before getting back to hardware design and things more concrete...
Stay tuned :)