The Mark 1 is a simulated computer that operates entirely within the Second Life server via LSL.
- Actually a Computer: The Mark 1 functions entirely using server-side LSL and can be interacted with in real-time in-world. The Mark 1's firmware is, effectively, an emulated computer for an architecture designed around Second Life.
- Removable Media: Data and scripts can be copied to and from floppy disks and external storage (both local and network-attached), allowing for backups and sharing.
- Keyboard Input: Users interact with the Mark 1 via the in-world keyboard, either by clicking, or using pass-through gestures from their real-life keyboard.
- Color Text & Graphics: The Mark 1's in-world display (either rezzed or attached to reduce land impact) can render any of the following:
- 48x20 or 96×20 code page 437 characters (plus a few extras) at effectively 432x320 pixel resolution
- 48x40px bitmaps in full 230-color mode
- 96x80px bitmaps in a 2x4px color-cell 230-color mode
- 192x160px bitmaps in a 4x8px color-cell 40-color mode (selectable from the full 230-color palette)
- Custom sprites using a software-supplied spritemap texture UUID
- SRAM and DRAM: The RAM interface offers a byte-addressed memory space using linkset data and script memory. The Mark 1 supports the following types of RAM:
- SRAM: Allocats system unit's linkset data. 64kB by default but can be changed.
- Fast-DRAM: Allocates linkset data in dynamically rezzed DRAM blocks. +1 net land impact and +3 seconds to boot time per 128kB.
- Slow-DRAM: Allocates script memory in dynamically rezzed DRAM blocks. +3 seconds to boot time per 16kB. Land impact depends on how many DRAM blocks are rezzed. Capacity per land impact is limited by number of slow-DRAM bank scripts in DRAM rezzer.
- Bootloader: Starts a replaceable bootloader script when the POST completes. The default bootloader provides on-screen instructions for how to acquire and install an operating system.
In addition, the Script Controlled Operating Environment (SCOPE), the official free operating system for the Mark 1, provides the following after user installation:
- Multiple File Systems: SCOPE includes support for the following file systems:
- Linkset Data File System: Uses linkset data to store a directory tree with files. The base system has a default 64kB capacity; external media has a 128kB capacity. LDFS is vulnerable to data loss if the system or media is accidentally linked.
- Property File System: Uses object properties (name, description, and hovertext) to store up to 64,895 UTF-8 bytes safely in a 256-prim object (smaller capacities are available with less land impact). Prim properties are the most reliable storage method since it is difficult to accidentally erase them.
- Script Memory File System: Uses a set of scripts that store a simplified directory tree with files in runtime memory. SMFS filesystems are experimental, slow, trivially erased, and only useful for diversified backups.
- Cloud File System: Uses an HTTP-accessible database to store a directory tree with files. CFS filesystems are optional and require a third-party server, but have effectively infinite practical capacity and allow for easy filesharing.
- Executable Files: LSL scripts are mapped to
.exe, .lib, and .svc files, which can be manipulated just like data files, with the limitation that only one copy of the file can exist on each disk due to LSL limitations.
- Process Contexts: The SCOPE Script Control Interface (SCI) allows programs (
.exe) to execute child programs and return values to parent programs, as well as start and stop libraries and services. Only one program can run at a time. Libraries (.lib) are started and stopped depending on what the active program has loaded. Services (.svc) run continuously in the background.
- Terminal: System administration console. Supports browsing storage, executing programs, and various command-line administrative tools.
- File Browser: Text-mode UI for browsing storage in a semi-graphical interface. Includes mouse support.
- Text Editor: Simple full-screen text editor.
- PC Speaker: The SCOPE sound driver supports single-channel PC-speaker-like chromatic scale tone generation for very basic music.
The Mark 1 also supports a variety of first-party add-ons:
- Microphone: Accepts input via chat (either from user only, or everyone nearby). Software that supports microphone input receive the entire message at once, but other software can still be used by switching the microphone into keyboard emulation mode.
- Flatbed Scanner: Reads texts from a notecard inside it. Works similar to the microphone.
- Printer: HTTP server that serves a
.txt file of all data sent to it for copying to a real computer, accessible via URL by clicking the page. Clicking and holding the page rips it, clearing the stored data.
- Mouse: Simulated mouse and driver service that uses one of the display's overlays to render a cursor that roughly follows the user's camera.
- Software-Defined Radio: Sends and receives chat messages on any chat channel.
- Stereo Speakers: The ExtAudIO driver service supports sending multiple synchronous channels of sounds and synthesized tones to be played on one or more speakers, with support for spatial audio using dynamically rezzed emitters.
Finally, a suite of additional software is available that adds additional functionality to the Mark 1:
- Media Player: The Mark 1 Media Player is a Global Media Format audio/video (
.gma, .gmv) file player.
- Tracker: The Pro Sheet Tracker is a tracker modfile (
.psm) editor and player. Requires ExtAudIO speakers.
- BASIC Interpreter: An interpreter for NB-BASIC, which is similar to TI-BASIC, the first language I learned!
- Bitmap Editor: A bitmap image editor that supports the Mark 1's various display modes.
- Self-Diagnostics: Sherlock is a diagnostic utility that can show various system configuration parameters, as well as check for unresponsive scripts, lost parent directories, missing stubs, orphaned symlinks, et cetera.
- PixMan: Pac-Man clone.
- Primtris: Tetris clone.
- Szym City: City economic management game.
- Szym Town: Roleplay city management game.
- Szym Tower: Skyscraper management game.
- MarsMiner : Mining game inspired by Motherload (2004 flash game).
The Mark 1 implements a set of documented interfaces for various components of a computer - RAM, file system, display, keyboard, etc. - using a special wrapper for llMessageLinked called the GSI link_message Extension Protocol (LEP). This allows user-installed software to interact with the Mark 1's firmware and operating system using a request-response model.
The Mark 1 also includes a Peripheral Control Interface (PCI) that uses a special wrapper for chat called the GSI Chat link_message Extension Protocol (CLEP). This allows external peripherals "connected" to the Mark 1 to communicate with firmware and drivers installed on the system unit.
Software written for the Mark 1 in LSL uses the NBS En LSL Framework and Mark 1 Toolkit.
I just think it's neat.
Real-world architectures are ultimately structured around bits and bytes. In LSL, this can only be done by packing integers into either lists or Base64-encoded strings. While the Mark 1's RAM exposes a traditional byte-addressed memory space for software use, these workarounds are both wasteful and slow at large scales due to limitations of how LSL manipulates variables, so running code directly from RAM is inefficient.
Similarly, interpreting a real-world language requires building an entire language interpreter for a very limited language of some sort. Running code as LSL scripts will always be faster, and there are probably more LSL scripters than BASIC enthusiasts in Second Life anyway. So the focus on the Mark 1 was LSL, while leaving language interpretation up to add-on software, such as NB-BASIC.
Some examples of other computers that implement existing architectures and languages:
- Frio Belmonte's F65 Computer directly processes most of the instruction set of the MOS6502 processor at approximately 40Hz, or about 0.004% of real-life speed.
- Shan Bright's Bright Basic Computer interprets a limited form of BASIC at 5-10 lines per second.
These computers are interesting but, ultimately, experimental and unintuitive. The Mark 1 is designed to be intuitive to computer users and engineers alike.
The Mark 1 evokes the experience of early 1980s PCs.
The hardware is loosely inspired by the original IBM PC (system unit) and the IBM PS/2 (keyboard, monitor), as well as various clones.
SCOPE, the first-party operating system, is roughly similar various text-mode DOSes, DOS extenders, and contemporary software of the 1980s, such as IBM TopView and the DOS Shell.
Primnet is conceptually similar to the Internet protocol suite.