ChrysaLisp

ChrysaLisp is a unique, 64-bit, MIMD operating system designed from the ground up for parallel and distributed computing. It's a complete, self-hosting environment featuring its own toolchain, a Virtual Processor (VP) for cross-platform portability, a responsive graphical user interface (GUI), a powerful command-line terminal with Unix-like pipes, an object-oriented assembler, extensive class libraries, a C-Script compiler for efficient low-level coding, a unique Lisp interpreter, an integrated debugger and profiler, powerful programers editor, and vector font engine.

Explore ChrysaLisp in action on our YouTube channel: ChrysaLisp OS on YouTube

Featured videos include:

• Installation, build process, and make test shorts.

• Demonstrations of the GUI environment and applications.

• Insights into the GUI compositor.

• A look at the integrated debugger.

• Self-Hosting: Includes its own assembler, Lisp interpreter, and build tools (make).

• Virtual Processor (VP): A 64-bit RISC-like target ensuring portability across x64, ARM64, and RISC-V64, LA64, with a VP64 emulator for unsupported platforms or bootstrapping.

• Parallel & Distributed: Designed for MIMD architectures, supporting various network topologies simulated via shared memory links or linked directly across physical machines over native TCP networks.

• Dynamic Binding & Loading: Functions are loaded and linked on demand, promoting efficient memory use and shared code among tasks.

• Object-Oriented Assembler: A powerful class system underpins the entire OS, from low-level assembly to high-level Lisp.

• C-Script Compiler: Allows C-like expressions to be compiled into efficient VP code within Lisp.

• Lisp Environment: A unique Lisp interpreter for scripting, development, and system tasks.

• Graphical User Interface: A custom GUI system built using ChrysaLisp's own object model.

• Command Terminal: A familiar pipe-style command-line interface.

ChrysaLisp currently runs as a hosted environment on:

• macOS (x64, arm64)

• Windows (64-bit x64)

• Linux (x64, arm64, riscv64, la64)

  • Special support for Raspberry Pi (3/4, 64-bit OS) in framebuffer mode.

Future goals include bare-metal operation, UniKernel appliances, and a WebAssembly target.

This guide is for users familiar with command-line tools and build systems. For a more detailed, step-by-step walkthrough, please see the docs/intro.md document.

• Latest Release (Recommended):

  1. Go to ChrysaLisp Releases.

  2. Download ChrysaLisp-snapshot.zip.

  3. Extract it. This contains source and pre-built VP64 boot image.

  (or)

• Master Branch:

  1. Ensure Git is installed.

  2. Clone:

git clone https://github.com/vygr/ChrysaLisp.git
cd ChrysaLisp

The GUI is on SDL3. make install uses it if it is on the machine, and SDL2 if it is not. See docs/intro/sdl3.md for a machine that has neither to hand, an older Mac or Pi, and for what each gives you.

• macOS:

  • Xcode Command Line Tools: xcode-select --install (if needed).

  • SDL3: brew install sdl3

• Linux (Debian/Ubuntu based):

  • Build tools: sudo apt-get install build-essential git pkg-config

  • SDL3: sudo apt-get install libsdl3-dev, where the release has it. To draw shaders on the GPU it has to be SDL 3.4 or later, which for now means building it from source, see docs/intro/sdl3.md.

  • Or SDL2: sudo apt-get install libsdl2-dev libsdl2-mixer-dev

• Windows:

  • Nothing to install, install.bat fetches SDL3.dll.

  • macOS Cross-Compile: To build Windows executables on macOS: brew install mingw-w64 then make -f Makefile.mingw windows_all.

• Raspberry Pi (Framebuffer mode):

  • Follow specific setup in docs/framebuffer.md or the comprehensive docs/intro.md.

This process compiles the host C/C++ programs and then uses them with a pre-supplied VP64 boot image to compile the entire ChrysaLisp system into a native boot image.

• macOS / Linux / Raspberry Pi (Desktop GUI mode):

make install

• Windows:

install.bat

• Raspberry Pi (Framebuffer mode):

make GUI=fb install

• Text User Interface (TUI):

  • macOS/Linux: ./run_tui.sh

  • Windows Batch: run_tui.bat

  • Windows PowerShell: .\run_tui.ps1

• Graphical User Interface (GUI):

  • macOS/Linux: ./run.sh

  • Windows Batch: run.bat

  • Windows PowerShell: .\run.ps1

  • Raspberry Pi (Framebuffer): ./run.sh -f

Once inside the ChrysaLisp TUI (Terminal app), you can rebuild the system:

• make: Compiles only necessary changes based on file modification times.

• make all: Recompiles all VP source files, regardless of modification times.

• make boot: Creates a new native boot image for the current platform.

• make docs: Generates reference documentation by scanning source files.

• make platforms: Compiles and builds for all supported target platforms, not just the host system. This includes creating boot images for each.

• make it: A comprehensive build that includes all, boot, platforms, and docs.

• make test: Runs internal timing tests for the make process.

You can combine options, for example: make all platforms boot.

A session, the nodes one launch script started, stops itself. It lives while it has a terminal or a desktop open. Quit the last desktop, or leave the TUI, and the rest of its nodes are stopped. Other sessions on the machine are left alone. nodes -g 1 opens another desktop.

To stop every node on the machine, whoever started it:

• macOS/Linux: ./stop.sh

• Windows Batch: stop.bat

• Windows PowerShell: .\stop.ps1

ChrysaLisp's architecture supports sophisticated distributed computing paradigms. You can simulate various network topologies (ring, mesh, cube, star, tree) on a single machine using the provided run_*.sh scripts.

Furthermore, ChrysaLisp features built-in, native TCP network linking (service/net) that allows you to link ChrysaLisp clusters directly across multiple physical machines (macOS, Linux, Windows, Raspberry Pi) over local LAN or wide area networks, without needing any external bridge daemons or shared memory hops.

To link machines together:

1. On the server machine, start a persistent listener:

link -l 3333

2. On any client machine, connect to the server by IP address or DNS/mDNS hostname:

link 192.168.1.185

# or using Bonjour / DNS:
link server.local

Alternatively, use zero-configuration LAN auto-discovery (-a):

1. On the server machine, listen and broadcast discovery beacons:

link -l 3333 -a

2. On any client machine, automatically discover and connect to LAN peers:

link -a

Both instances automatically discover each other's nodes, merge their routing tables, and distribute tasks and applications seamlessly across the combined compute cluster.

For detailed instructions on these advanced topics, please refer to the comprehensive docs/intro/intro.md guide.

• Clean: To remove compiled object files and revert to the snapshot state:

make clean

(This will require unzip to be installed).

• Snapshot: To create a distributable snapshot.zip containing only essential pre-compiled binaries and the VP64 boot image (primarily for developers maintaining the project):

make snapshot

This is typically done after make it from within ChrysaLisp !