The LoseThos 64-bit PC Operating System:
x86_64, preemptive multitasking, multicore, open source, public domain
What is LoseThos?
    LoseThos is a "supplemental" operating system because you'll want to dual boot with another operating system, since
    you can't access the Internet and because it's not really suited for a usage other than screwing around writing
    programs.  It's really good for that, though -- lots of fun.  Except for graphics, LoseThos is modern -- 64-bit, multi-cored
    and with HD Audio.  It does not depend on other code for anything.  In fact, you can use it as the sole operating system
    on a computer with no network.  For those of you with fierce operating system cult loyalty, relax, it's not a zero sum game.

    LoseThos is simple.  It runs on a standard 64-bit PC, nothing exotic, and compiles and runs native x86_64 code -- no
    byte code or interpreter, anywhere.  It has no memory or other protections.  If this sounds bad instead of good to you,
    go use Linux or Windows and leave me alone.  LoseThos is not for everybody.  You like stick or automatic? A kayak or a
    Titanic?

    It's a live CD, so you can test drive or install.  Hypervisors, virtualization and emulation are insulting.  Go away if you
    won't boot the CD.

    WARNING:  LoseThos is nonstandard.  Test-drive the live CD to see something new and elegant, even if you don't
    become a user.  Almost everything works in live CD mode because there is a RAM drive you can play with (B:).  If you
    like it and can afford to try something nonstandard, install it from the same live CD.  It's free.  
Unregistered version includes:
  • 64-bit x86 Kernel with Multicore support.
  • 64-bit Compiler/Assembler, flavor of C/C++.  More than C, less than C++ and different.
  • Source files and the command line window can have graphics, links, icons, trees, colors, margins -- everything is
    seamless and uncluttered.  No resource, object or executable files.
  • 64-bit pointers. Physical addresses are used at all times. Single, system-wide, address map.  (Virtual addresses identity
    mapped to physical.)  All memory, even more than 4 Gig, can be accessed by all tasks at all times, directly.  It's as
    though the CPU paging feature is not used.
  • Highest CPU privileged mode at all times.  No off-limits instructions. No time lost changing modes.  What?  You need a
    nanny?
  • Switches tasks in half a microsecond.
  • CD/DVD reading and writing, ISO9660 file system
  • 640x480 16 Color VGA Graphics
  • Boot loaders for CD-ROM or hard disk
  • Keyboards & Mice
  • Hard Drives, Support for FAT32 and LoseThos native file systems, File compression
  • Graphics Library
  • Tools/Utilities including Profiler
  • Demos and Documentation
  • Games
  • Bible and hymns
  • All source code included, including the 64-bit compiler!  Only compiles natively -- you can't use gcc.  Instead, boot
    LoseThos to compile.

    LoseThos never executes code I did not write except a couple BIOS config calls.  It's 100,000 lines of public domain
    code with no GPL restrictions, written by me, over the last 6 years, full-time.  It was written completely from scratch with
    no code as a starting point.  

Registered version also includes:
  • LTZ utility for uncompressing LoseThos files from Windows or Linux.  (Not needed for normal operation -- You normally
    boot LoseThos and it compresses or uncompresses files automatically, on the fly.)
  • Dictionary

Strategical decisions that make LoseThos small and simple:
    Low line count and simplicity are the goal, with LoseThos being small enough for someone to get their head around.  
    That's one reason I'm thinking of doing all the programming myself, not accepting contributions of code, and limiting my
    ambitions for LoseThos hardware and featurewise.

    Small resource use is not really a goal.  You don't get a cookie for reducing a 64-bit machine's RAM below 512 Meg.  I
    can run it on 32 Meg or less, but who cares.  I can delete the Bible and cut the install size, too.  Low user program line
    count is the ultimate goal (No, not with pseudo simplifications which actually make it more complicated.)  

    "Hello world" takes one line -- statements can be placed outside a function like a script file:
    coutln "Hello World";
    and drawing a line on the screen can be done in four lines, or three if you want BLACK:
    GrBitMap *base=GrAlias(gr_persistent_base,Fs);
    base->color=RED;
    GrLine(base,100,100,300,200);
    GrDel(base);
    My vision comes from my remembering my Commodore 64.  Back then, practically all computer users programmed and
    tinkered.  Programs were in magazines.  I had a book which literally told what every address location was used for.  
    Linux is intimidating.

  • 640x480 16 colors.  Period.  Forever.
  • No Security.  Everything runs at the highest privilege level.  No networking.  A Titanic is orders of magnitude more
    complicated than making a 2 second boot time.  Unlike a mainframe, on a home system other users are not affected if a
    crash occurs.  LoseThos is for users doing their own programs.  Every programmer has locked-up a task before with a
    bug and had to kill it.  With LoseThos, you just reboot.  It's actually quicker.  
  • Pure 64-bit.  No legacy support.
  • One platform architecture.
  • Updates whole screen at 60 Hz.  Doesn't mess with rectangles telling what's changed.  It's optimized for full screen
    games where keeping track of invalid rectangles does not help.
  • All intermediate values in the compiler are extended to 64-bit when fetched and only 64-bit computations are done
    intermediately.  No type-checking.
  • One editor/word processor/browser thing for the command-line, source code, documentation browser, dialog forms,
    everything.
  • One Font, 8x8.
  • No child windows.  One window per task.  Buttons and stuff are widgets, not child windows.  Tasks can have child tasks
    with their own windows, though.
  • Threads = processes = tasks, no distinction (One memory map, duh! All cores, even.)
  • One memory map for everybody -- virtual addresses set equal to physical.
  • One language and compiler for command-line scripts and code.
  • No object files.  Whole files are processed almost exclusively, allowing for compression.
  • All tasks have a heap and a symbol table.  Think of the scope as that of environment variables in other operating
    systems.  As text is typed at the command line or you run programs by #including them, the symbols go in the table.  If a
    symbol is not found, the parent task's is checked.  The father of all tasks has the API symbols you'll need waiting in it's
    table.  No need to #include headers.  No need for namespaces -- scoping occurs automatically.

Promises:
  • LoseThos will always run everything in kernel mode, ring 0.  All programs will have full access to memory, I/O ports,
    instructions, etc.  Yes, this means you can crash LoseThos very easily.  Yes, this means no security.
  • LoseThos will always "identity map" virtual memory.  (Virtual addresses are the same as physical.)  It's just like paging
    doesn't exist.
  • LoseThos will never have networking.
  • LoseThos will always have one video mode, 640x480 by 16 colors, unless this mode might become unavailable on
    computers in the future.  You can assume the screen will be the same for everybody.  There's plenty of CPU for very
    little screen to update -- only 1/37th the power needed for a 1600x1200x24 bit mode.  (Compare video memory size to
    judge needed work.)
  • The LoseThos operating system will be free, but I might sell applications or support, or possibly do adware.
  • LoseThos will be 100% open source with all source included, unless device drivers or something can only be included
    with non-disclosure agreements.
  • All function args and returns will be 64-bit -- no plans for C++.
  • LoseThos documents are not for printing -- they're dynamic and intended for the screen.  There will always be just one
    font, a fixed-width font, and I do not have plans for Unicode, just ASCII.
  • LoseThos is not for multimedia.  Games will be created by programmers, not artists -- calculated sounds and images.  
    Who has time to twiddle pixels all day and who has voice actors and owns a 1930's radio show recording studio!

Not Promised:
  • LoseThos is subject to change and backward compatibility is NOT guaranteed. However, changes are a pain for me,
    too.  It's mostly done.  You are far safer working with JIT compilation than static binaries because I can add members to
    classes, reorder members in classes, add default args to existing functions, change #define values, etc. all without
    breaking compatibility if you recompile JIT.
Get LoseThos 64-Bit PC O.S. at SourceForge.net. Fast, secure and Free Open Source software downloads
Trivial Solutions Corporation
Happy programmers make us happy.
Use MagicISO, Roxio or whatever to burn a CD from an ISO file in Windows.  If you don't know what an
ISO file is, it's a standard for CD-ROM images which allows a boot capability.  Linux supports ISO
burning, but Windows is evil in this regard and you have to buy something to burn an ISO.  It's nothing
more than an exact block-for-block image of the CD.  After making a CD, boot it.