Last updated 17 September 2005.
To fill the void, I threw together the original Tutti simulator in 1998. Rather than emulate the hardware, which at the time I didn't fully understand, it simply tried to act like a Tutor as much as possible -- a simpler undertaking at least at that time. Though it was very limited and only supported the title screen, menu and a small taste of BASIC, it was enough to give non-users a feel for the system. It was well received and eventually went through versions 0.2, 0.2a and (in 2003, the last major update) 0.3. It was written for the Commodore 64 because that's where my skills lay, and also because by writing a version anyone could run under a Commodore emulator, it could be run on any system with a Commodore emulator available (and that meant a lot of computers, not just Winblows, er, Windows). Although it was not a complete simulation in any sense of the word, by 0.3 it supported token portions of GRAPHIC mode, GBASIC, BASIC and the MONitor, and allowed basic elemental operations in all of them.
Tutti's major problem was that the system had to be arduously reverse engineered to filter out all the quirks of its programming, and eventually this became dreadfully inefficient and increasingly difficult for me to put together. As the basics were established, the ability for me to update in a timely fashion got weaker and weaker. Moreover, by this point, other more skillful hackers were looking at the Tomy hardware and determined to come up with their own emulators themselves.
In May 2003 Ian Gledhill released a sluggish but functioning SDL-based emulator for Windows, which although glacially slow, was the first real Tomy Tutor emulator and finally brought cross-computing to the Tutor world. Raphael Nabet eventually released his own driver for the MESS multi-system emulator in version 0.70 based on his own work with the Texas Instruments MESS drivers and his research into the operation of the CLA. I tested this driver out while he was working on it, and it seems to work not only efficiently, but authentically. In fact, MESS is nowadays my own preference for emulating the Tutor despite being Tutti's original author.
For this reason, I have decided to discontinue maintaining Tutti and leave it frozen forever at version 0.3, as most people will not want to bother with it. However, I will leave it available for those architectures that can emulate a Commodore 64 but do not have a MESS port (of which there are a few, though this is dropping as MESS reaches more and more systems). Also, because Tutti does not require ROMs to operate, it is the only emulator or simulator that can be fully legally operated by someone who does not own a Tomy Tutor already.
On the other hand, I will consider resuming work on it if there is interest in my doing so, especially since I was hoping to expand the Tutor interface to allow cross-development and importing Commodore image files, as well as fix a few bugs in the system without impacting compatibility. Also, a modified form of Tutti may emerge to emulate the Pyuuta series as to date the MESS driver is not known to support the Pyuuta Jr. or the original Pyuuta. If this is something you think you would like to see, please let me know at firstname.lastname@example.org.
The below section is the Tutti instruction and "FAQ" page, more or less the same from its final version (0.3), along with screenshots and downloading instructions. Obviously, it is no longer the only simulator or emulator, but most of the rest is current. I leave it more or less as is. Have fun. -- Cameron Kaiser
Tutti (which stands for TUTor Tiny Implementation) is ... wait for it ... the world's only attempt to even simulate the Tomy Tutor. And as the author, I can tell you, bar none, it really sucks and it probably won't get a whole lot better. But hey, for all you emulator phr33aks out there, this is the best it gets. At least you'll be able to play with something that's 20% of one, right? And you'll be able to tell all your friends about it, who will have no idea what the sam heck you're talking about.
Okay, enough self-deprecation. On with the information ...
99 ENDgenerates an entry error -- but the screen editor is just about finished and all the little quirks are emulated (like flashing the sprites on every line, the scrolling, etc.) Since we now have an almost exhaustive GBASIC reference, you can count on GBASIC continuing to evolve (see the FAQ question on GBASIC below).
GRAPfor GRAPHIC mode, etc.).
A Commodore 64 and disk drive.
Several reasons. A big one is portability: if I just wrote this on a PeeCee, it would only ever run on PeeCees and people on Macs (like me), and Amigas, and RiscOS boxes, and Unix boxen, and whatever, wouldn't be able to join in the fun. The advantage is that by writing this on a Commodore 64, not only will it be able to run on a venerable and still widely-supported classic system, but it will also run anywhere a Commodore emulator is available (i.e., just about any modern OS and quite a few older ones).
Most importantly, however, my programming skills on PCs suck and the Commodore 64 is just easier and a lot more fun to program. So there.
If you don't have a Commodore, then get an emulator (I recommend Frodo, since it's fast, free and fully compatible, and absurdly portable: it runs on many Unix flavours, Win95/Win98/WinNT, EPOC, Mac, Amiga, RISC/OS and BeOS; coming soon for PocketPC and Zaurus) and emulate Tutti on the emulator. Ironic, eh?
You can download Frodo from The Official Frodo Home Page.
No. See the next question.
Right now, not too much. Tutti simulates the 9995, and doesn't
emulate it (i.e. the ROMs are reverse-engineered and run native on the
6510 -- the 6510 isn't emulating a 9995 running the Tomy ROMs), which means
that it's a matter of coding a program that acts like a Tomy rather than
a program that acts like the hardware. Hence a simulator, more than an
emulator, and that's why you don't need to dump ROMs or, more likely, leech
a pirated copy from
Dave's Classics Gnutella KaZaa. That's
what you were going to do, weren't you? Don't lie.
The hardware that is truly emulated is the sound and video circuitry. The 64's SID sound chip is more than up to the task of doing the sound, and the VIC-II vid chip manages character graphics just fine. However, the VIC-II requires some hellish raster work to emulate 256x192x16 graphics. First, the Tomy 9918ANL has a different palette, and second, it can use 2 colours per 8x1 cell unlike the VIC-II which is limited to 2 per 8x8. The palette multiplexer works (it's flickery but it does the job), but the second, while possible, requires so much CPU overhead to track the raster that the stock 64 may not be up to the task of doing that *and* giving the user snappy response in the paint box. The palette multiplexer is solely in "tinker" phase and isn't in the current version, and probably won't be in the next either. Tutti's overworked IRQ subsystem has enough to worry about without that.
Tape is emulated by the disk drive, if I ever reverse-engineer enough of the Tomy OS to the point where it can save and load things.
BASIC is supported and one of these days will be finished, but right now supports so few keywords as to be largely useful only for getting error messages, and does not support programmatic execution at all currently.
Graphics mode is also supported, along with sprites. However, because of the resolution constraints, you can't actually draw anything yet (though you can move the cursor around and make it look like you're doing something).
The MONitor is supported as of 0.2a.
GBASIC is supported as of 0.3, and the GBASIC screen editor is just about
finished, but it doesn't support much more than that yet (everything except
END keyword generates an entry error). You can still play
around in it though.
The Commodore vid chip generates a 320x200 display plus the border; the 9918ANL generates a 256x192 display that, at least on my 1702, goes into the border of the screen. So, I draw the 256x192 screen in the middle 256 pixels of the regular Commodore 320x200 view; this is useful because the overscan can be simulated on the 64 by just showing it the leftover 32 pixels on other side, but since Tutti is effectively drawing a 256x192 screen on a 320x200-plus canvas, it's going to be very horizonally shrunk. The screenshots here have been corrected for this.
It does not currently support drawing pictures (because of the resolution issue) or drawing or moving sprites; it also does yet not fully support GBASIC or BASIC; and you can't use cartridges or cartridge ROM dumps with it.
No, because Tutti doesn't emulate the 9995, so it can't run the object code. Never fear, because since I like the games so much, I might port them to the 64 anyway separately of Tutti.
Eventually. 'Till then, you're limited to direct mode execution of selected commands -- see the Programming Section which in the keywords list indicates which ones are simulated in Tutti.
Note that because the SCELL() hack for getting into the Tomy OS depends on oddiments of the Tutor's internal memory organisation, undocumented tricks like that will probaby never be supported. Mercifully, this little backdoor is just about unheard-of in Tutor programs except around Wizard Kludgefinders (tip of the hat to James Host).
Yes, to some degree. The internal paint box will probably be fully, or at least largely supported, when I figure out the raster issue. Even if I don't support actually *drawing* pictures in GRAPHIC mode, I do plan to support allowing you to draw images in Doodle!, for example, and import them into GRAPHIC mode. Sprite editing will eventually be supported since there are no raster issues impeding that.
Definitely. Virtually all the GBASIC keywords are now known and tested, and
their behaviours are well-defined, so we finally have the exhaustive (?)
resource we need to create a working simulation. Again, because of internal
differences between the C64's and the Tutor's graphics architecture, certain
tricks such as using
CELL workspace for transferring colour and
bit pattern data may not work correctly on the C64, but all officially
documented behaviour will one day work (granted not much is officially
documented ;-). Most importantly, Tutti's GBASIC will also have
some of the bugs fixed (including the notorious crash-on-undefined-statement
bug), but bugs in keyword interpretation will be preserved so that the
emulator doesn't improperly accept programs that won't run on a real Tutor.
Likewise, since the MONitor is now well-documented, its functions will be supported fully as well (they're not that complicated anyway).
Currently supported commands are in the Programming section.
Because I refuse to write an SCPU-only application. (This is for the Commodore 64 programmers in the audience who know to what I'm referring.)
Not yet (since you can't *create* graphics, sprites or programs ;-), but you will be able to save and load in the future. The format will be Tutti-specific, however, although I will hopefully have documentation on the format. At least this way you can exchange programs for the emulator on-line and load them into your real C64 or your emulated Commodore to run in Tutti, but be advised this approach will not support Tutor-format tape files even if you have a tape recorder or Datasette.
Cartridge games and software, never, because the CPU isn't emulated (see the specific question about cartridges, and what Tutti supports).
As for cassette tape, maybe one day, but right now it can't because I don't know how to read a Tomy-format cassette. However, a GBASIC or BASIC program may be portable if it's downloaded to a binary dump file that the Commodore can pick up; how you actually *get* the binary and dump it to disk isn't my problem, but as we have since spied on the Tutor BASIC code and learned what the tokens are, there is some hope for at least a conversion process. (We're not that far along with GBASIC yet.)
The issue, though, is getting Tutti BASIC to the point where it simulates all the instructions on the original machine. This is no mean feat, especially since Tomy didn't lose any sleep on technical documentation.
If you're a casual emulator d00d, you're in the wrong place. This emulator doesn't play any games, and the only games it may ever play are those you write yourself. Leave now. You don't want this. Ask for ROMs on comp.emulators.cbm so I can flame you.
However, if you're a TI freak or interested in what the machine could do or just finding out what it is, this may be your only chance, since you probably won't ever see a Tutor except at a swap meet in Paducah. And it's so bad that I'll perpetually leave it as freeware.
Just LOAD it and RUN it like a BASIC program.
In BASIC, type MENU
In graphics mode, get into graphic mode 4 (press MOD three times), and press MON for the MONitor. Then type MENU. If you got into the MONitor but want to stay in graphics mode, type GRAPHIC.
In GBASIC, exit with a line like 99 END, and then type MENU at the MONitor prompt.
These bugs are known, but since Tutti won't be updated further, they won't be fixed. Regardless, send any comments if you like to email@example.com. Please note that the emulation has always been incomplete. Thanks!
Also, since the VIC-II is not patched in this version, the colours are only approximations of the true palette and are not wholly accurate.
The Tutor banner screen. Tutti reports its version (the real machine also reports its own; my Tutor claims to be version 2.3).
Pick an option, any option.
Shee, what do you have to do for some assistance?
Sacre bleu! You can change the screen colour in BASIC, and even clear it!
Yay! Watch that rocket cursor move, baby!
Sing the sprite alphabet song! A, C, B, D, E, F ... um ... something wrong there ...
Reggae MON! We're jamMON! MON Dieu, these puns are MONstrous! Har har har!
"Why, Dorothy, you've always had the power to go back home!"
Back to the Emulation page | Back to the main page