
PC/GEOS - beefhash
https://github.com/bluewaysw/pcgeos
======
shortformblog
I'm really happy to see this. I wrote a story about PC/GEOS, also known as
GeoWorks, a few years ago, and the end of the story was somewhat sad, as the
death of one of the founders of BreadBox effectively left the future of the
operating system in flux.

[https://tedium.co/2016/04/28/geoworks-
windows-3-1-competitor...](https://tedium.co/2016/04/28/geoworks-
windows-3-1-competitor/)

Hopefully open-sourcing it will keep this great operating system alive. It
should have beat Windows 3.1.

~~~
azinman2
What makes it great in 2018? Why keep alive?

~~~
fit2rule
It could function as a great alternative to Windows or FreeDOS for those of us
who don't want to pay a Microsoft tax whenever we buy a new computer.

It might be useful as the basis of a new mobile-phone operating system.

It is certainly interesting to the archaic-computer users out there who are
maintaining old systems as a means of consolidating computing culture, as we
lean more and more towards homogenisation ...

~~~
azinman2
What makes an 80s/90s era 16-bit OS great in 2018? If you want free/open
source, why not run Linux or FreeBSD or any if the many modern alternatives
that have 64-bit support, preemptive multitasking, protected memory, modern
VM, new software actively being developed for it, drivers for modern hardware,
support for SSDs and USB 3.0 and nvidias, etc etc?

Similarly, there’s nothing about geos that’s appropriate for a mobile device.
If you want to start with something existing, Android is already open source
and has a ton of existing software. Or try fuschia if you want more bleeding
edge.

Now if you say it’s for a hobby, or fun, or whatever then I can understand.

~~~
david-given
GEOS would run on systems _three_ orders of magnitude smaller than the ones
you describe. It was intended to work well on machines with a single megabyte
of RAM, and did.

I have an Android ADP1 phone on my desk at work; the first Android phone which
was ever released (the G1 with the custom paint job on the back). It's a
paperweight; there's nothing useful I can do with it, and it won't even talk
to the Google servers any more. However, obsolete as it is, it's still
staggeringly _more_ powerful than anything GEOS ever ran on.

The biggest thing systems like GEOS do for the modern developer is to be an
example: to demonstrate just what you can do with a tiny, tiny amount of code.

(Oh yeah, GEOS also had virtual memory and preemptive multitasking.)

~~~
johnm
PC/GEOS didn't have virtual memory the way people think about it--it was a
handles based approach so that memory could be moved when it wasn't being
actively used.

~~~
mschaef
Windows and MacOS did something like this too. The memory APIs worked in terms
of blocks of memory identified through 'handles' rather than pointers.

To get a pointer, there were additional calls that would enable blocks
(identified by handle) to be locked and unlocked. The lock calls provided
pointers that were deemed valid until the block was unlocked.

The net of this is that the OS could do things like relocate and page blocks
that weren't locked, and do it without hardware assistance.

It really was a nice, minimalistic way to approximate some 'big iron' features
on modest hardware. (Although it's hard to imagine anyone wanting to go back.
:-) )

------
dana321
The source code for the C64 version is available here too:

[https://github.com/mist64/geos](https://github.com/mist64/geos)

~~~
orionblastar
There is a Mega65 computer with a GUI based on GEOS at
[http://mega65.com](http://mega65.com) that is a Commodore 65 clone. The 65
has a 64 mode and 65 mode for better color and sound.

------
cowmix
I wrote the business plan for my Arizona based ISP on PC/GEOS back in '92 on a
IBM PC AT.

[https://www.dropbox.com/s/n78x5cp8na4iilq/InternetDirectIncP...](https://www.dropbox.com/s/n78x5cp8na4iilq/InternetDirectIncProscpectus_akaInternetHutInc..pdf?dl=0)

~~~
linuxlizard
I was in college at the time. Wrote a /lot/ of technical papers with GeoWorks.
The word processor and draw had great integration.

~~~
linuxlizard
Also had a Tetris that is still the nicest clone I've ever played. For years
after, I'd load my GeoWorks onto an old PC just to play the Tetris. I probably
have the GeoWorks disks in my garage still.

~~~
bdamm
I'm 100% confident I've played that exact Tetris, but on Linux with Motif on
X. So I think you'll find, if you poke around enough, that source code is
alive and accessible.

~~~
johnm
I doubt it. Ours was written in our homegrown x86 assembly language for our
own OS kernel.

------
mtmail
"Their newest PC/GEOS, 4.x, is now a full productivity and Internet suite,
including Web Browser and Email"

[https://en.wikipedia.org/wiki/GEOS_(16-bit_operating_system)](https://en.wikipedia.org/wiki/GEOS_\(16-bit_operating_system\))
has more history. I played with it around Windows 3.1 times.

------
UncleSlacky
There is still a (quiet) mailing list covering all things GEOS, NewDeal
Office, Breadbox Ensemble etc. here:
[https://groups.yahoo.com/neo/groups/geos-
talk/info](https://groups.yahoo.com/neo/groups/geos-talk/info)

------
compsciphd
I remember running Geoworks on my 8086 panasonic desktop (as souped up an 8086
as their can be, vga card, 40MB hard disk (then doublespaced!). I remember it
coming with the Pre-AOL AOL client.

With that said, all the apps I had for it were the ones that came with it, so
in a sense it was just a glorified version of micrsoft works + some games. It
was cute and in a way gave a longer life to the 8086 machine than it deserved
having, but, they missed the microsoft concept of "developers, developers,
developers"

~~~
johnm
Actually, to be more clear... The original graphical AOL client for the PC was
a PC/GEOS application. It booted GEOS and straight into the AOL GEOS
application.

~~~
mschaef
Interesting. Was there any carryover between that and QuantumLink/QLink (via
Commodore GEOS). I'm assuming not...

~~~
johnm
Technologically, no. Business-wise, I don't recall.

~~~
mschaef
Thanks... tbh, it was the technology that interested me more.

I remember pretty amazed at GEOS on the C64, but have never fully understood
if there was a connection to the other GEOS implementations (or the nature of
that connection if it existed).

~~~
johnm
Commodore GEOS was created by the same company as PC/GEOS. I only worked on
PC/GEOS.

------
Dowwie
Geoworks came packaged with my 386sx 16mhz magnavox pc. I also remember this
software package called "America Online" that I could connect to with my 2400
baud modem but it was way too expensive so I didn't sign up.

~~~
hakfoo
I thought I was the only one with a Magnavox 386 PC. It was back when they had
John Cleese as a spokesman, as I recall.

------
classichasclass
There was also the OmniGo 100, an HP LX series machine that had GEOS in ROM:

[http://www.hpmuseum.net/display_item.php?hw=200](http://www.hpmuseum.net/display_item.php?hw=200)

------
david-given
Now, there's a name I haven't heard in a long time...

Back before 2000 I did a tonne of stuff with GEOS; wrote a couple of terrible
programming languages, some not-so-terrible games, a bunch of hacking, and
even managed to write a Linux system call emulator allowing you to run Linux
binaries under GEOS. (Well, ELKS. That still counts as Linux, right?) (In
hindsight I should have gone for Minix binaries instead, as nobody back then
had heard of ELKS, or now, and it would have let me run the Minix C compiler
under GEOS.) See [http://cowlark.com/geos-software](http://cowlark.com/geos-
software).

It's an exceptionally elegant system, providing a multi-threaded, object-
oriented system with outline fonts, full vector graphics support (based on
things called GStrings), virtual memory (including virtual memory _files_, so
disk I/O is done for you by the system), long filenames and symlinks, and a
component-based architecture allowing for massive code reuse, all on a 640kB
PC/XT running at 4.77MHz. On a faster machine it simply flew.

The core of it is a smart linker/loader which allows code and data segments to
be loaded, patched together on the fly, and dropped on demand. All data is
relocatable, allowing it to be rearranged or swapped out. The core language is
'object-oriented assembly' \--- assembly with high-level features for message
sending and deserialising objectes; the OO system has some very nice tricks up
its sleeves, such as the specific/generic UI mechanism. Your app describes its
UI in generic terms using classes like Trigger; these have holes in their
inheritance tree. When your app gets loaded, the system fills in these holes
with matching classes from the UI system. So a Trigger can turn into a Motif
button, or an old-school GEOS button, or the Brother UI button, etc, depending
on what it's loaded on.

You could also write in GOC, which is a proprietary preprocessed C not
dissimilar from Objective C; it was, um, interesting. The code it generated
had to be compiled with Borland C, which was expensive. The entire development
environment wasn't great: there was a command-line debugger which had to run
on a completely separate PC connected to your main machine with a serial
cable. I rarely bothered with it.

Sadly the whole architecture is intrinsically tied to the i86 segmented
architecture. Although, modern machines are so fast that I'm sure you could
cross-assemble the i86 code to a modern architecture and just do the
segmentation in software. The system's so well designed (and small and fast)
that it'd probably still be an order of magnitude lighter than, say,
LibreOffice. I still miss GeoDraw.

(I got a job offer from Geoworks once! I turned them down to stay with Tao, an
equally doomed operating system startup...)

~~~
drudru11
Nice testimonial.

Do you know of any documentation online that covers the loader and other good
bits?

Also, what is/was Tao?

~~~
david-given
Tao was a UK OS company that produced operating systems call Taos and int _e_
nt (emphasis theirs); their killer feature was binary portability and
assymetric multiprocessing, so you could have multiprocessor machines built of
several different random architectures and treat them all as a single message-
passing system. Code was converted from bytecode to native machine code at
load time. It was small, elegant and very cool.

Turns out people didn't want to buy that.

------
verytrivial
I _loved_ GEOS and annoyed all my friends ranting about it in the early 90s.
It really made me appreciate that with skill you can get orders of magnitude
more functionality out of the resources at hand.

------
jackfraser
I had GeoWorks on a C64 and was amazed by what it could do. Felt much more
cohesive than Windows 3.1 in terms of being a consistent desktop environment.

Anyone remember KeyDraw? GEM-based vector graphics package for DOS, based on
the GUI libraries from GEM Desktop which was the descendant of GEOS /
GeoWorks, if I recall. Fantastically learnable program that introduced 5-year-
old me into the world of vector art.

(On that front, anyone remember Aldus Intellidraw? Even better, _still_ a
better UI than Illustrator, though held back by lack of antialiasing and weak
postscript support).

~~~
cmrdporcupine
GEM predates GEOS by many years. It was a product of Digital Research, and was
started in the early 80s by Lee Jay Lorenzen who had worked (or interned?) at
Xerox on the Star and wanted to bring those concepts over to commodity x86
desktop machines.

Lorenzen went on to create the successful DTP program, Ventura Publisher,
which itself used a bundled copy of GEM.

The wikipedia article on GEM has a good chunk of history:
[https://en.wikipedia.org/wiki/Graphics_Environment_Manager](https://en.wikipedia.org/wiki/Graphics_Environment_Manager)

A 68000 port of GEM and GEMDOS (which itself was a kind of fork of DR's own
CPM/68k) were the basis of the Atari ST operating system "TOS". Some of the
tales of how that all went down are documented by one of the participants
here:

[http://www.dadhacker.com/blog/?p=995](http://www.dadhacker.com/blog/?p=995)

[http://www.dadhacker.com/blog/?p=1000](http://www.dadhacker.com/blog/?p=1000)

All of this an entirely separate effort from GEOS/GeoWorks, though in some
respects the two efforts are similar in that they aimed to bring the full WIMP
experience to fairly low-powered machines. But the philosophy was quite
different. PC/GEOS was written in a lot of assembler, specifically for x86
(after they'd done something similar for the C64 in 6502 assembler in fact),
specifically for commodity PCs. GEM was written in C with some amount of
portability in mind (in theory), and ran on top of DOS, CP/M, or GEMDOS (I
believe there was also attempts to get it to run on top of Unix). The first
version of GEM was developed and ran on the Apple Lisa hardware.

~~~
joshu
I recommend reading the entirety of the dadhacker site. It's amazing.

------
k__
lol, back in the days I found GEOS on a disk for my C64.

I was blown away to see a desktop/gui for the first time in my life.

It felt like going back to the stone-age when I got a PC and it just had DOS
and Norton Commander, haha

------
happycube
GEOS-SC sounds interesting as a potentially more portable "modern" version -
did MELCO wind up owning the rights to it? If not does the source for that
still exist...?

------
amiga-workbench
I'll have to get this compiled and installed on my IBM AT, nice to see
something compatible with my 286.

------
rbanffy
Now we need to make it compile with gcc (or clang) and run on a Unix-like OS.

~~~
dfox
Given the fact that it is mostly written in weird semi-custom x86 macro
assembler it would entail significantly more work than you expect :)

~~~
fit2rule
Yah, the assembly language is going to be a bit of an issue. But I wonder if
there wouldn't be some interested parties to turn it all into portable C code
..

~~~
rbanffy
You can always compile it to function calls that emulate x86 opcodes.
Considering the difference in speed between a 386SX (which ran GEOS
acceptably) and a Core i3, it'll probably be fast enough.

Besides, the whole environment can probably run from within the cache of a
modern CPU.

~~~
fit2rule
That's a neat idea, and probably kind of feasible .. I wonder if anyone will
take up the challenge and produce a clean C-portable version .. I'm guessing
some of the folks around ContikiOS might be intrigued by this idea. Off to
other forums to discuss it further ..

