Hubbry Logo
Lilith (computer)Lilith (computer)Main
Open search
Lilith (computer)
Community hub
Lilith (computer)
logo
8 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Lilith (computer)
Lilith (computer)
Lilith (computer)
View on Wikipedia
from Wikipedia

DISER Lilith
DeveloperETH Zurich
ManufacturerModula Computer Systems
Product familyWirth
Typeworkstation
Released1980; 46 years ago (1980)
Introductory price$8000
DiscontinuedYes
Units sold120[1]
Units shipped120
MediaFloppy disk 5.25 in (13.3 cm) 140 K
Operating systemMedos-2 (Modula-2)
CPUAMD 2901
Memory256 K (131,072 16-bit words)
Storage15 MB hard disk
Display12 in (30 cm) monochrome bitmapped
Dimensions15.5 in × 15 in × 14.5 in (39 cm × 38 cm × 37 cm)
Marketing targetResearch
SuccessorCeres

The DISER Lilith is a custom-built workstation computer based on the Advanced Micro Devices (AMD) 2901 bit-slicing processor, created by a group led by Niklaus Wirth at ETH Zurich.[2][3] The project began in 1977, and by 1984 several hundred workstations were in use. It has a high-resolution full-page portrait oriented cathode-ray tube display, a mouse, a laser printer interface, and a computer networking interface. Its software is written fully in Modula-2 and includes a relational database program named Lidas.

The Lilith processor architecture is a stack machine.[2] Citing from Sven Erik Knudsen's contribution to "The Art of Simplicity": "Lilith's clock speed was around 7 MHz and enabled Lilith to execute between 1 and 2 million instructions (called M-code) per second. (...) Initially, the main memory was planned to have 65,536 16-bit words memory, but soon after its first version, it was enlarged to twice that capacity. For regular Modula-2 programs however, only the initial 65,536 words were usable for storage of variables."[4]

History

[edit]

The development of Lilith was influenced by the Xerox Alto from the Xerox PARC (1973) where Niklaus Wirth spent a sabbatical from 1976 to 1977. Unable to bring back one of the Alto systems to Europe, Wirth decided to build a new system from scratch between 1978 and 1980, selling it under the company name DISER (Data Image Sound Processor and Emitter Receiver System).[5] In 1985, he had a second sabbatical leave to PARC, which led to the design of the Oberon System. Ceres, the follow-up to Lilith, was released in 1987.

Operating system

[edit]
Medos-2
DeveloperSvend Erik Knudsen
Written inModula-2
OS familyWirth
Working stateDiscontinued
Marketing targetResearch
Available inEnglish
Update methodCompile from source code
Package managerModula-2 modules
Supported platformsLilith (AMD 2901)
Kernel typeModular, object-oriented
Succeeded byOberon

The Lilith operating system, named Medos-2, was developed at ETH Zurich, by Svend Erik Knudsen with advice from Wirth. It is a single-user, object-oriented operating system built from modules of Modula-2.[3][6][7]

Its design influenced the design of the operating system Excelsior, developed for the Soviet Kronos workstation (see below), by the Kronos Research Group (KRG).[8]

Soviet variants

[edit]

From 1986 into the early 1990s, Soviet Union technologists created and produced a line of printed circuit board systems, and workstations based on them, all named Kronos. The workstations were based on Lilith, and made in small numbers.[9]

Mouse

[edit]

The computer mouse of the Lilith was custom designed, and later used with the Smaky computers. It then inspired the first mice produced by Logitech.

[edit]
  • The vertical screen, keyboard and mouse of the Diser Lilith
    The vertical screen, keyboard and mouse of the Diser Lilith
  • Vertical tower central unit
    Vertical tower central unit
  • Internal view of the Lilith, showcasing the CPU boards
    Internal view of the Lilith, showcasing the CPU boards
  • Front view of the Lilith workstation
    Front view of the Lilith workstation

References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Lilith (computer)

View on Grokipedia
from Grokipedia
Lilith was an early developed at between 1978 and 1980 by and his team at the Institute of Computer Science. It featured a custom microprogrammed 16-bit processor, high-resolution bitmapped display (initially 768 × 592 pixels), and a for input, making it one of the first systems to incorporate these elements in a compact workstation design. The project was inspired by Wirth's experiences with the during a 1976 sabbatical at PARC, aiming to create an affordable machine optimized for , , and . Lilith's hardware included 64K to 128K words of (expandable), a cycle time of 140 nanoseconds (approximately 7 MHz), and support for peripherals like Ethernet and laser printers in later models. Its operating system and applications were implemented in , a programming language Wirth designed concurrently (1978–1979) as an extension of Pascal, emphasizing modular structure, separate compilation, and static type checking to facilitate reliable . Approximately 60 units were produced and deployed at by 1982, primarily for teaching and administrative tasks, with a operational by early 1979 and the first pilot series of 20 units delivered in December 1980. The system pioneered a with windows, icons, scroll bars, pop-up menus, and title bars, influencing subsequent designs, though commercialization efforts failed due to cost and market challenges. was decommissioned at by 1990 but remains notable for demonstrating the integration of advanced hardware and software tailored for personal computing in an academic setting.

History

Origins and Development

The development of the Lilith computer was initiated in 1978 by Niklaus Wirth at the Swiss Federal Institute of Technology in Zurich (ETH Zurich), where he served as a professor of computer science, with the goal of creating a personal workstation to advance programming education and research. Motivated by the need for an accessible computing environment that emphasized structured programming, the project drew direct inspiration from Wirth's 1976 sabbatical at Xerox PARC, where he experienced the Alto workstation's innovative graphical user interface and mouse-based interaction. Unlike the resource-intensive Alto, Lilith was designed as a simplified, cost-effective alternative tailored for academic settings, prioritizing support for Wirth's emerging Modula-2 language to enable efficient software experimentation and teaching. Wirth led the effort, collaborating closely with Richard Ohran, who handled much of the hardware engineering, and Jürg Gutknecht, who contributed significantly to software design and implementation. Additional team members, including compiler specialists Christian Jacobi and Leo Geissmann, supported the integration of tools, ensuring the system aligned with Wirth's vision for a cohesive hardware-software ecosystem. The project's collaborative nature at reflected a hands-on approach, with development spanning 1978 to 1980 and yielding the first functional prototype by 1979. Central to the initial design were goals of optimizing for compilation through a custom microprogrammed processor architecture, implemented using 2901 bit-slice components to support a tailored instruction set. This choice enabled efficient interpretation of M-code, 's compact intermediate representation, while maintaining a focus on compactness and performance suitable for single-user workstations in educational contexts. The design emphasized simplicity and modularity, avoiding unnecessary complexity to better serve as a tool for exploring advanced programming paradigms.

Production and Deployment

The first prototype of the Lilith workstation was completed in early 1979 at , following development that began in 1978 under the leadership of and hardware specialist Richard Ohran. In December 1980, a pilot series of 20 units was manufactured in , USA, under Ohran's supervision and delivered to to support initial testing and . By 1982, approximately 60 Lilith systems were in use within ETH's Department, with production continuing through hand-assembly at the institution to meet academic demands. Efforts to commercialize Lilith began in 1982 through the company DISER, which marketed it as a research-oriented ; a initial batch of 10 units was produced in the at a of 20,000 Swiss francs. Overall, around 140 units were manufactured in total, with approximately 120 sold primarily to academic and institutions, though the venture failed commercially after six months due to from lower-cost microprocessors and chips. Production was limited to small-scale efforts, as the custom fabrication of bit-slice processor boards based on the 2901 and the integration of high-resolution displays posed significant engineering challenges, restricting output to hand-built assemblies at between 1980 and 1984. The high cost per unit made Lilith accessible only for institutional use, preventing widespread adoption beyond specialized environments. Lilith systems were primarily deployed in Zurich's Department for teaching programming concepts, document preparation, and research in , serving as a platform for development from 1980 onward. They remained in active use for educational and administrative purposes until around 1990, when they were decommissioned and replaced by more advanced workstations like the Ceres series to accommodate growing computational needs.

Hardware

Processor and Architecture

The Lilith computer employed a custom microprogrammed (CPU) constructed from four Am2901 bit-slice processors, forming a 16-bit arithmetic and logic unit (ALU) with a register stack supporting up to 16 entries for efficient expression evaluation. This design implemented a 16-bit stack-based optimized for the M-code instruction set, which was specifically tailored to the programming language and included native support for structured data types such as modules, records, and separate compilation via and relative addressing. The microcode controlling the processor was stored in a 2K × 44-bit programmable (PROM), enabling flexible implementation of the instruction set with an average of five micro-instructions per M-code instruction. The processor operated at a clock speed of approximately 7 MHz, corresponding to a basic cycle time of approximately 140 ns per micro-instruction, which ensured deterministic execution timings critical for real-time graphics operations. This performance level allowed the Lilith to achieve execution speeds comparable to contemporary minicomputers while prioritizing efficiency in compiled code. The system architecture featured a unified 16-bit address bus and 16-bit data bus that interconnected the CPU, main (up to 128 kwords), and interfaces, with a separate I/O bus for peripheral control to avoid memory contention.

Display and Graphics

The Lilith workstation featured a 15-inch cathode-ray tube (CRT) display utilizing a technique, which was among the earliest high-resolution graphical interfaces for personal workstations. The initial configuration provided a resolution of 768 pixels horizontally by 594 lines vertically in a portrait-oriented format, enabling detailed text and graphical rendering suitable for programming and document preparation tasks. Later variants improved this to 704 × 928 pixels in a vertical orientation, maintaining the monochrome 1-bit depth for black-and-white output. The graphics architecture incorporated dedicated support through microcode instructions for operations such as bit-block transfers (BitBlt) and line drawing, facilitating efficient manipulation of data. The frame buffer resided directly in main memory, allowing the CPU to access and update display content without specialized video RAM, while the display controller refreshed the screen at 25 frames per second using interlaced scanning. This setup supported a 50 Hz effective field rate through 50 interlaced half-, balancing performance with the hardware constraints of the era. These display capabilities were instrumental in pioneering graphical user interfaces, enabling features like overlapping windows, icons, and pop-up menus that influenced subsequent designs. By integrating high-resolution bitmapped graphics with , the provided a foundational platform for interactive environments, distinct from contemporary character-based terminals.

Input Devices

The Lilith computer's input system was centered on a custom three-button optical mouse and a QWERTY keyboard, both engineered by the team to enable precise interaction with its high-resolution graphical interface. The mouse utilized a 10x10 grid encoder for position tracking, achieving a resolution of approximately 400 (dpi), which allowed for accurate cursor control in applications like text editing and menu navigation. This design emphasized ergonomic functionality, with the device measuring roughly 10 cm in length and 6 cm in width. Connected through a proprietary serial interface, the mouse employed simple quadrature encoding to detect movement, with signals processed via direct hardware interrupts for low-latency response. Complementing the mouse, the keyboard adopted a standard layout augmented with dedicated mappings for programming symbols, such as assignment operators and type declarations, to streamline tasks. Lacking conventional ports like PS/2 or USB—unavailable at the time—all inputs were fully integrated into the system's custom low-speed I/O bus, ensuring seamless operation within the 's closed hardware architecture. This integrated approach prioritized reliability and minimal latency, supporting the Lilith's role as an early personal for engineering and programming.

Memory and Storage

The Lilith computer utilized dynamic RAM (DRAM) chips for its main , organized as 16-bit words, with a base configuration of 128 KB (65,536 words). This capacity was expandable to 256 KB in production models through additional modules, supported by custom controllers that managed refresh cycles and addressing. The memory interface was tightly integrated with the processor's 16-bit bus, enabling efficient data transfer for the M-code interpreter central to its operation. For secondary storage, the Lilith relied on removable disk cartridges compatible with Honeywell Bull D120/D140 drives, each providing approximately 10 MB of capacity (formatted to about 9.8 MB usable). These cartridges served as the primary medium for the operating system, applications, and user data, with no fixed hard drives in the initial design; a single-sided double-density provided backup functionality. The cartridges were highly sensitive to dust and environmental contaminants, necessitating careful handling and sealed storage to prevent . Access to storage occurred via (DMA) channels, allowing the disk controller to transfer data blocks independently of the CPU, with transfer rates up to 720 KB/s under optimal conditions. The file system, implemented through the Medos-2 operating system's DiskSystem and FileSystem modules, was optimized for the programming environment, supporting small, named files with contiguous sector allocation on the cartridges. Files were limited to a maximum of 192 KB each, with up to 768 files per cartridge organized via fixed directory structures for quick lookup and access. Sequential reads were enhanced by read-ahead buffering (up to 2 KB), while random access used an LRU-style buffer management with 16 concurrent descriptors. The system lacked support, restricting the directly addressable space to 64 KB of the main memory (excluding an upper bank reserved for display bitmaps, fonts, and resident files), with expansion achieved through hardware banking via a dedicated instruction to switch address spaces.

Software

Operating System

The operating system for the Lilith computer, known as Medos-2, is a single-user system written entirely in the programming language to promote portability across platforms. It employs non-preemptive multitasking via coroutines, enabling cooperative execution of multiple programs without dedicated process support, limited to up to 16 active programs through a simple scheduler in the Monitor module. The core of Medos-2 is the Sequential Executive Kernel (SEK), a memory-resident program comprising 14 to 15 hierarchically organized Modula-2 modules, such as Program for memory management and linking, FileSystem for abstract file handling, and DiskSystem for storage operations, totaling under 15,000 words including buffers and fonts. Device drivers are implemented as modular components, including DisplayDriver for raster scan display management with bitmap and font support, mouse input handling integrated into the GUI framework, and D140Disk or DUODisk for interfacing with Honeywell Bull D120/D140 disk drives. A window manager oversees GUI elements, leveraging the DisplayDriver to maintain default bitmaps in the upper memory bank and facilitate user interactions on the high-resolution screen. The provides a hierarchical structure where modules form the fundamental units, stored on removable disk cartridges or floppy disks with contiguous sector allocation for efficiency. It supports up to 768 files per 10 MB cartridge (maximum file size 192 kB, total capacity 9.4 MB after system files), managed via a 768-entry directory, page allocation tables, and 16 buffers of 256 bytes each, with read-ahead optimization for and write-through for modifications to ensure . All file system operations, including multi-media support through CreateMedium procedures, are encapsulated in modules for seamless integration with user programs. Medos-2 boots by loading the PC.BootFile from a or the integrated 15 MB Winchester hard disk, which scans the file directory to build allocation tables and initializes hardware components. The boot sequence then activates the SEK kernel, followed by the command interpreter (Comint) module, presenting a shell-like interface that prompts for user and program activation via files processed by the Executer linking-loader.

Programming Languages and Tools

The primary programming language for the Lilith workstation was , designed by between 1977 and 1978 at specifically to support the system's software development needs. extended concepts from Pascal with features such as modular decomposition for separate compilation, coroutines for concurrent programming, and low-level hardware access through mechanisms like the ADDRESS type and type transfers, enabling direct manipulation of machine addresses and bit patterns while maintaining principles. These elements made ideal for implementing both application software and system components on Lilith, emphasizing reliability and efficiency in a single-language environment. The compiler for was self-hosted, meaning it was implemented in itself and executed directly on the workstation without requiring an external host machine. Developed initially on a PDP-11 and ported to , the evolved from a multi-pass design to a highly optimized single-pass version by 1984, which dramatically reduced compilation times—for instance, from approximately four minutes to 45 seconds for typical modules—thanks to the workstation's 64K-word memory and the bit-slice processor's architecture. It generated M-code, a compact stack-machine tailored to 's microprogrammed bit-slice processor, allowing for efficient execution through hardware interpretation while supporting optimizations like inline code inclusion for performance-critical sections. Lilith's development tools were fully integrated and also written in , forming a cohesive environment that promoted practices. The suite included a with mouse-driven cursor control and windowed interface for source code manipulation, a symbolic debugger for inspecting runtime states and post-mortem analysis using symbol files generated during compilation, and a linker for combining separately compiled modules into executable M-code segments. These tools operated seamlessly within the workstation's , enabling rapid iteration without cross-compilation dependencies. The development workflow on Lilith centered on an efficient compile-edit-debug cycle optimized for single-user use, where programmers could edit modules, compile them incrementally, link as needed, and debug interactively—all natively on the machine. This self-contained approach eliminated the need for separate development hosts, fostering by leveraging Modula-2's separate compilation model, where interface specifications in definition modules ensured type-safe integration of components. The tools' tight integration with the operating system further streamlined execution, allowing developers to test coroutines and hardware interactions in real-time.

Variants

Soviet Clones

In the , the Kronos series of workstations emerged in the mid-1980s as an inspired by the original design, developed at the Computing Center under the Siberian Branch of the USSR Academy of Sciences. This project, led by a small team including Dr. Vadim Kotov as part of the MARS initiative, drew directly from Niklaus Wirth's concepts to create a 32-bit system optimized for high-level languages like , reflecting the Soviet emphasis on indigenous computing for research and defense applications during the late era. The development occurred amid reforms, allowing greater access to Western technical literature, though the team relied on available documentation rather than direct hardware smuggling. Key modifications distinguished Kronos from , incorporating Soviet-manufactured TTL/TTLSh logic components to replace imported bit-slice processors, enabling a shift to full 32-bit with a fast hardware stack and support. Memory capacity was expanded significantly, with models like Kronos 2.5 supporting up to 2 MB of on-board RAM, far exceeding Lilith's typical 256 KB configuration, to handle more complex software tasks. The operating system, Excelsior, mirrored Lilith's foundation but added modularity for multi-tasking and real-time interaction. Additional enhancements included an improved subsystem and peripheral integration, such as basic networking capabilities for multi-user setups in academic environments, which were absent in the original . Production of Kronos workstations, such as the Kronos-2.6WS model, was limited to small pilot series, assembled for use in Soviet institutes, defense projects (e.g., satellite software development at NPO PM), and exhibitions like Nauka-88. These systems employed cost-effective local materials to bypass import restrictions, though this resulted in lower clock speeds (around 3 MHz) compared to potential Western equivalents. By the late , as the USSR dissolved, production waned, but surviving units contributed to early post-Soviet computing research.

Successors and Derivatives

Following the development of the Lilith workstation in 1980, pursued several official successor projects to advance its workstation architecture and software ecosystem, focusing on improved performance, modularity, and integration with evolving programming paradigms. The primary hardware evolution came with the Ceres family of workstations, initiated in 1986 as a direct follow-up to . Ceres-1, released in 1987, featured a 32-bit NS32032 processor running at 10 MHz, 2 MB of dynamic RAM, a 40 MB hard disk, and a high-resolution 1024x800 raster-scan display, marking a shift from Lilith's 16-bit bit-slice design to a more standard microprocessor architecture while maintaining compatibility with programming. Subsequent iterations included Ceres-2 in 1988 with an upgraded NS32532 processor, 4-8 MB memory, and 80 MB storage for enhanced virtual addressing, and Ceres-3 in 1990, a cost-optimized, diskless variant using the NS32GX32 processor for student laboratories, emphasizing shared networked resources over local storage. Parallel to this hardware progression, the Oberon project, launched in late 1985 by Niklaus Wirth and Jürg Gutknecht, represented the software successor, evolving Lilith's Modula-2 and Medos operating system into a unified, object-oriented environment. Inspired by Wirth's 1984 visit to Xerox PARC, Oberon combined a new programming language—extending Modula-2 with type hierarchies and single inheritance—with an integrated operating system, first implemented on Ceres-1 hardware by mid-1987 and reaching its initial release in fall 1988. The system's design prioritized a bare-metal bootstrap process, dynamic module loading without a separate linker, and a flat B-tree file system, enabling efficient text and graphics handling via abstract data types like piece-chain texts for editing. By 1989, networking capabilities were added using RS-485 SDLC at 230 Kbit/s for file transfer, messaging, and centralized servers, supporting a constellation of Oberon workstations in a decentralized environment. The transition from Lilith to these successors involved porting key software components, such as library modules and utilities from Medos-2, to the environment on Ceres hardware, with adaptations for 32-bit addressing and new display formats ensuring where feasible. Lilith systems were gradually phased out by 1990, as Ceres and became the standard for ETH's education and research, with Oberon serving in introductory programming courses until around 2003. Derivatives of the Lilith lineage extended beyond ETH's core projects through conceptual influences rather than direct clones. Wirth's workstation principles, refined in Lilith and carried forward in , indirectly shaped graphical user interfaces in systems like the and Macintosh, stemming from shared inspirations at PARC during Wirth's sabbaticals. Additionally, 's portable design facilitated ports to commercial platforms, including the and Sun stations starting in 1989, preserving its networked, modular ethos across diverse hardware.

Legacy

Technological Impact

The Lilith computer represented a significant innovation in personal computing by introducing an affordable, high-resolution graphical user interface (GUI) integrated with mouse input in its prototype form by 1980, predating the commercial release of the Xerox Star in 1981 and the Apple Macintosh in 1984. This design, modeled after the Xerox Alto but implemented with more accessible technology including a bitmap display supporting windows, icons, and pop-up menus, demonstrated the viability of interactive, graphics-oriented workstations for non-specialist users. Niklaus Wirth's experiences at Xerox PARC and subsequent publications on the system helped disseminate these concepts, contributing to the evolution of GUI paradigms in subsequent commercial products. In education, the Lilith played a pivotal role at , where initially approximately 20 units were deployed in the early 1980s—half for student labs and half for research, with the total at ETH reaching 60 units—training thousands of students in structured programming principles through hands-on use. The system's entire software stack, including the operating system, compiler, and applications like text editors and databases, was developed in , a language Wirth created specifically for it, emphasizing modularity, separate compilation, and concurrency to foster disciplined practices. served as the direct foundation for Wirth's later language and exerted influence on the design of Ada, particularly in tasking and modular structures. The further advanced the concept of a single-language operating system, proving that a high-level language like could handle all aspects of without assembly code dominance, a feasibility that informed later minimalist OS designs. Its architecture is frequently cited in historical accounts of workstation development, paralleling influences from the on systems like Sun and Apollo workstations through shared emphases on networked, graphics-capable personal computing. Despite these contributions, the Lilith's strictly academic orientation at constrained its commercial dissemination, with production totaling over 300 units, though limited to academic and select industrial deployments without widespread market adoption. Nonetheless, its use of 2901 bit-slice processors showcased advanced microprogramming techniques, enabling custom instruction sets optimized for that highlighted hardware-software co-design principles influential in subsequent embedded and workstation engineering.

Preservation and Emulation

Few original Lilith computers survive today, with approximately ten units known to exist in various collections and private hands. Notable examples include one held by the in , designed by and his team at for optimizing programming. maintains units in its departmental archives as part of its cultural heritage preservation efforts, alongside other pioneering systems like Ceres. Restoration of these machines presents significant challenges, including the degradation of custom cartridges and aging cathode-ray tube (CRT) displays, which require specialized handling to avoid further damage. Emulation efforts have played a crucial role in preserving Lilith's functionality on modern hardware. The open-source Emulith simulator, developed by Jos Dreesen starting in 2008, provides a register-level emulation of the Lilith's and Medos-2 environment, utilizing unchanged original and disk images for high fidelity. This accurately replicates hardware components such as the high-resolution display, mouse, keyboard, and cartridge disk drive, achieving performance equivalent to the original 7 MHz system on a 1 GHz PC while running the native operating system. Earlier work includes a 1983 Lilith bootstrapped on a Perkin-Elmer 3220 UNIX system to cross-compile , now available on for continued use. Documentation supporting preservation includes Niklaus Wirth's seminal 1981 paper, "The Personal Computer 'Lilith'," which details the system's and principles. has digitized portions of its archives, making hardware manuals and software descriptions accessible online. Community-driven projects on host ROM dumps and emulator code, enabling reproduction of original firmware and facilitating software recovery from surviving disks. In the 2020s, highlighted during its Department of Computer Science's 40th anniversary in 2021, featuring archival materials and historical context in online spotlights and exhibits. Virtual recreations via emulators have supported educational initiatives, allowing interaction with original software on contemporary platforms without risking physical hardware.

References

  1. http://pascal.hansotten.com/niklaus-wirth/lilith/history-of-lilith
  2. https://inf.ethz.ch/news-and-events/spotlights/infk-news-channel/2021/05/from-the-archives-lilith.html
  3. https://ed-thelen.org/comp-hist/lilith.html
  4. https://inf.ethz.ch/department/history.html
  5. http://oberon2005.oberoncore.ru/paper/m2_lil.pdf
  6. https://inf.ethz.ch/news-and-events/spotlights/infk-news-channel/2021/10/timeline-d-infk.html
  7. https://bitsavers.org/pdf/eth/lilith/ETH7346_Medos-2_1983.pdf
  8. http://pascal.hansotten.com/niklaus-wirth/lilith/history-of-lilitha-brief-history-of-modula-and-lilith-n-wirth-abstract-in-the-years-1978-1980-the-workstation-lilith-was-developed-at-eth-zurich-it-featured-a-microprogrammed-processor-a-high-resol/
  9. https://www.ethistory.ethz.ch/rueckblicke/departemente/dinfk/forschung/weitere_seiten/lilith/index_EN/popupfriendly/index_EN.html
  10. https://www.modula2.org/modula2-history.php
  11. https://computerhistory.org/wp-content/uploads/2019/08/core-2002-02.pdf
  12. https://free.oberon.org/files/Modula2_Oriented_OS.pdf
  13. https://ethz.ch/en/news-and-events/eth-news/news/2014/02/vater-von-pascal-wird-80.html
  14. https://bitsavers.org/pdf/eth/lilith/Lilith_hardware_manual.pdf
  15. http://pascal.hansotten.com/uploads/lilith/docu/Lilith_mcode_interpreter.pdf
  16. http://www.bitsavers.org/pdf/eth/lilith/ThePersonalComputerLilith_1981.pdf
  17. https://dl.acm.org/doi/pdf/10.5555/800078.802510
  18. https://www.computerhistory.org/collections/catalog/X1051.91
  19. https://oberoncore.ru/_media/library/wirth_the_personal_computer_lilith.pdf
  20. http://pascal.hansotten.com/uploads/lilith/Emulith_Manual.pdf
  21. http://pascal.hansotten.com/niklaus-wirth/lilith/
  22. https://github.com/afborchert/lilith
  23. https://amturing.acm.org/pdf/WirthTuringTranscript.pdf
  24. https://inria.hal.science/hal-01568396v1/document
  25. http://www.kronos.ru/
  26. http://www.kronos.ru/literature/philippova
  27. https://collection.sciencemuseumgroup.org.uk/objects/co8565007/kronos-2-6-ws-32-bit-workstation-computer-russian-academy-of-science
  28. https://bitsavers.org/pdf/eth/ceres/Ceres_Handbook_198612.pdf
  29. https://people.inf.ethz.ch/wirth/ProjectOberon1992.pdf
  30. https://ethz.ch/en/news-and-events/eth-news/news/2024/01/computer-pioneer-niklaus-wirth-has-died.html
  31. https://www.ethistory.ethz.ch/rueckblicke/departemente/dinfk/forschung/weitere_seiten/oberon/index_EN/popupfriendly/index_EN.html
  32. https://www.computer.org/csdl/magazine/an/2024/01/10488021/1VMR2LPbhrW
  33. https://people.inf.ethz.ch/wirth/projects.html
  34. http://pascal.hansotten.com/niklaus-wirth/lilith/photos-of-lilith/
  35. http://pascal.hansotten.com/niklaus-wirth/lilith/emulith/
  36. https://github.com/afborchert/lilith-emulator
Add your contribution
Related Hubs
User Avatar
No comments yet.