Lisp runtime, compiler, and development environment

Processes are not Unix processes

The CADR manual defines a process around a stack group scheduled when its wait predicate becomes true. Processes share Lisp objects and the machine address space; run reasons and arrest reasons control eligibility. Genera expands that model with explicit priority, queue, timer, lock, monitor, event, and synchronization modules, but it still does not make each application an address-space-isolated Unix process. The live process displays are documented in Inspector and Peek and MIT Peek.

Resources are reusable object pools

The RESOUR/resource layer belongs beside storage rather than beside files. It defines managed pools whose objects can be acquired, initialized, and returned, reducing allocation and setup cost for frequently reused objects. A resource is not a Unix file descriptor or a package dependency merely because all three can be described as resources in modern prose.

Core load order

The public src/lmdoc/lispm.files inventory shows the early system as a deliberate load sequence rather than a monolithic evaluator. The runtime-relevant portion can be grouped without erasing its file identities:

The same inventory continues into windows, networking, fonts, diagnostics, and the CADR microassembler. Those are consumers or adjacent development systems, not additional reader/compiler stages, and are routed to their own dossiers.

Compiler pipeline

The third-edition manual describes three ordinary ways to reach the compiler:

1. COMPILE replaces an existing interpreted definition with a compiled function.
2. ZWEI compiles a definition, region, buffer, or file from the editor.
3. QC-FILE reads a source file one top-level form at a time and writes a QFASL binary.

UNCOMPILE can restore the saved interpreted definition when one was retained. That is a development convenience, not source recovery from arbitrary machine code. QC-FILE treats top-level forms according to compile/load/evaluation rules: macro definitions and declarations may have compile-time effects, while load-time forms are represented in the output. The compiled-object dossier explains why this does not make a QFASL a source archive.

Language facilities and historical caution

System 46's LOOP is the Lisp Machine's stylized-English loop macro, not the later ANSI Common Lisp definition by virtue of sharing its name. Its structure facility is NSTRUC; generalized assignment support is distributed through the macro and compiler substrate rather than presented as a modern standalone library. Claims about precise Common Lisp conformance would be anachronistic for this release.

Declared system boundary

System 303 makes the architecture easier to audit because sys/sysdcl.lisp declares systems and modules explicitly. The top-level SYSTEM aggregate includes the following relevant components:

ZWEI, FED, COLOR, PRESS, HACKS, CONVERSE, and ISPELL appear as separate or commented optional systems, not hidden compiler phases. This is why the catalog does not describe every application in a System 303 source checkout as part of the resident core.

SYSTEM-INTERNALS

The SYSTEM-INTERNALS declaration gives the most complete bounded inventory of the runtime. Its definition group includes process, reader, stack-group, numeric, and storage definitions. Its main group contains:

The CLPACK, CLMAC, and GENRIC names establish a Common Lisp compatibility effort. They do not, without a conformance suite and dated standard target, establish complete ANSI Common Lisp conformance. The live System 303 listener explicitly described its context as package USER with a “standard traditional syntax” readtable, which is the safer release-specific statement.

System macros

The separate SYSTEM-MACROS declaration loads DEFMAC, LMMAC, ERRMAC, STRUCT, SETF, and TYPES. This separates language-building definitions needed early from the later SYSTEM-INTERNALS implementation. LOOP remains in the main system. Rebuilding these modules is part of the system-construction lifecycle, not an ordinary application action.

Compiler system

System 303's compiler declaration is a compact, exact inventory:

The separate GARBAGE-COLLECTOR system recompiles storage definitions and GC. It is a maintenance boundary around the same runtime collector, not a second interactive collector application.

From one core to coordinated subsystems

The licensed System 452.22 declaration lists the following relevant components in the main SYSTEM build:

The macro group loaded ahead of the components contains DEFMAC, LMMAC, structure definitions, STRUCT, SETF, LOOP, Command Processor macros, and a ZWEI collection module. The fact that the build must load these macros does not make all language facilities macros at runtime; the declaration itself notes that some of the files also contain functions.

Common Lisp and ZetaLisp contexts

Genera treats language context as more than a package variable. A registered Lisp syntax can establish a readtable, required package relationships, numeric bases, and other defaults. The directly relevant Evaluation Context commands are:

In the fresh museum world, Show Lisp Context reported that Common Lisp syntax was enabled, the printed package name was USER and was really COMMON-LISP-USER, and both bases were 10. This is an observation of the preserved world, not a claim that every Genera Listener always starts in that context.

Package-model difference

The CADR manual's package model is hierarchical: symbols can be referenced through superpackage/subpackage prefixes, the printer chooses prefixes needed for readable output, and a file's mode line or package association controls compile/load context. Genera's Common Lisp context instead uses Common Lisp packages and use lists while retaining ZetaLisp compatibility. A matching printed prefix therefore does not prove that name resolution followed the same package algorithm in both generations.

Scheduler inventory

The Genera scheduler declaration is ordered rather than an unstructured directory. At this dossier's grain its modules form the following groups:

This structure explains visible operations such as inspecting process state or waiting reasons without implying that the scheduler is a separate GUI.

Garbage-collection modes and commands

Genera exposes three related collection strategies:

• ephemeral and dynamic collection reclaim newer generations incrementally;
• immediate collection performs a complete collection now, optionally by area;
• in-place collection compacts without requiring the ordinary copying space and can also be selected by area.

The complete Garbage Collection command area at this grain has four commands:

By-Area is normalized internally to immediate selective collection. Selective without Immediately is reported as meaningless. With no collection mode named, Start GC defaults to enabling dynamic and ephemeral collection. Those are source behaviors that are more precise than treating Start GC as one undifferentiated full collection.

The runtime probe invoked only Show GC Status. In that exact cold-booted world, ephemeral GC was on, dynamic GC was off, the collector process was waiting for the ephemeral level to fill, and the generation count was 122: one full, one dynamic, and 120 ephemeral collections. The display also estimated immediate and in-place space thresholds. These quantities are volatile observations, not release constants; no collector setting or collection was changed.

Shared pipeline

The LISP-COMPILER declaration separates portable compiler work from machine code:

Architecture-specific systems

The shared compiler chooses a machine family rather than emitting one universal instruction set:

The VLM is declared as an Ivory-family target. The host executable emulates that architecture; it is not the Lisp compiler's x86-64 back end. Lower-level Ivory linking and host integration belong to the architecture dossier rather than being folded into the language compiler.

Source correspondence survives compilation

The file compiler records source locators and PC intervals that relate compiled code back to source forms. Debugger and editor commands use those correspondences to show or edit source when available, and fall back to disassembly when they are not. This is richer than a raw instruction vector but still does not preserve the unique original source: macro calls, comments, dead code, and optimization-erased abstractions can be absent. See recovering code from worlds for the preservation consequence.

DEVELOPMENT-UTILITIES is a release boundary

Genera 8.5's release roster records System 452.22, Development-Utilities 439.0, and CL-Developer 428.0. They are not synonyms:

This distinction prevents three common catalog errors: calling all development commands “the compiler,” treating Common Lisp Developer as the base Common Lisp runtime, or treating C/Lisp embedding support as the L-BIN file format.

Complete directly relevant Command Processor surface

The Show Expanded Lisp Code expansion subset contains exactly macros, inline functions, style checkers, optimizers, and constants. Its default subset is macros plus inline functions; constant folding, compiler-equivalent treatment, repetition, and whole-form descent default off.

Show Compiled Code is also wired into presentations: a disassemble gesture on a compiled function, function specification, or live stack frame invokes it. In the Debugger, Control-X Control-D accelerates the same operation for the current frame. The implementation deliberately preserves the exact compiled-function object when one was presented, so redefining its name does not silently redirect an inspection of an older frame to newer code.

Registered compiler names do not prove installed products

The Compile File source registers dispatch labels for Lisp, C, Pascal, Prolog, and Fortran. Before invoking one, it looks up the named package and compiler function. If either is absent, it reports that it does not know how to compile that type yet. Therefore a compiler label in command completion establishes a dispatch hook, not that the optional language product is loaded or licensed in the current world. This source-only guard is easy to miss in a menu or handbook inventory.

Editor integration

Zmacs adds compile-definition, region, buffer, changed-definitions, file, and warning workflows over the same compiler environment. Those keys and menu commands are exhaustively inventoried in Genera Zmacs keybindings and MIT ZWEI/Zmacs. They are not duplicated here as though they were a second compiler.

Safety protocol

Both sessions used only this project-owned definition:

(defun museum-d22-square (x) (* x x))

The sessions checked whether the definition was compiled, invoked COMPILE, called the result with 9, expanded a small WHEN, and disassembled only the synthetic function. No source file, system, patch, world, collector setting, package context, or installed definition was changed. System 303 removed the function with FMAKUNBOUND. In Genera, a later attempt to add unsupported raw keyword text to a Command Processor line entered input correction; the attempted cleanup form was therefore not visibly accepted. The run is not presented as cleaned up in guest memory. Its unchanged private-world hash and explicit unsaved-state-discard record show that the definition did not persist.

System 303 observation

The fresh session d22-runtime-compiler-cadr-20260718, generation 1, ran from 2026-07-18 07:41:27 through 07:47:05 EDT. It booted System 303-0, declined to set a wall-clock time, and reported Experimental System 303.0, ZWEI 129.0, and microcode 323. The public base and private session disk began with SHA-256 bb16e46ad81decfe1efe691d36b6aa4ce3fd4ffb82474365de3520989d397cb5. The base retained that hash at stop.

The visible sequence established:

Runtime observation: this exact 768 by 963 System 303 frame is the minimum selected state that shows the compiled result, macroexpansion, and CADR instruction listing. It contains no installed source or manual text.

The executed usim hash was 707a77d23e28ea1c45ae0eb0145dc181fa7ba649b9defc30044d4f847ac2c5be; the public System source check-in and unchanged private tree hash were respectively 4df393c68d7f083ce42d5c377039d26043cc18a9031ace28258dc97f4137eb91 and 21f5215de973aa6ccbddb817f2d64edd95ee1014c3028a9b0711ea7c741b807e. The 7,005-byte final run record has SHA-256 83b322014ee05c8b68384d3f534406b9057027be03ce2ee39e36830556338be3. Shutdown was clean: forced_stop=false, state_may_be_incomplete=false, and both usim and Xvfb exited 0.

Genera 8.5 observation

The fresh isolated session d22-runtime-compiler-genera-20260718, generation 1, ran from 2026-07-18 07:47:20 through 07:53:34 EDT. The licensed archive was 206,213,430 bytes with SHA-256 89fb3e76b91d612834f565834dea950b603acf8f9dbacacdd0b1c3c284a2d36e. The base and private world were each 54,804,480 bytes with SHA-256 a8ee5e86cc7e322f7385af3e0cd579d7650d4dcfc3ce328acbf8b25515dd0672 at start and stop. The VLM and debugger hashes were 9f5e18d5770f973879716182b6856ef5a8ee9d3b2bb907476ea0cf35986aa4c7 and 2db918cfe8f35f52c7ff4b7695b0ecd3bb85e41a3327ea5a94874edf05edb54a.

The visible compiler sequence established:

Runtime observation: this exact 1,200 by 900 frame documents functional compiler behavior in the unconfigured museum world. The entered function and test form are researcher-written; no proprietary source listing is displayed.

The subsequent read-only commands established the current Common Lisp context and collector state described above:

Runtime observation: the displayed capacities, word counts, thresholds, and generation counts are measurements of this one cold-booted private world. The command changed no GC option and started no collection.

The default invocation Show Expanded Lisp Code (when t 7) then printed the form as (WHEN T 7), while the earlier direct MACROEXPAND-1 returned IF. Source shows that whole-form descent and repetition default off; the observation therefore must not be rewritten as “Show Expanded Lisp Code is the same as MACROEXPAND-1.” A later attempt to append raw keyword text on the same command line was rejected by this input path as additional arguments. That failed syntax probe is not used to infer whether selecting the keywords through Command Processor completion would work.

The complete Genera action log contains 22 intent/outcome records, 10,979 bytes, SHA-256 f0a226c73117f7124a5fc24aab9db597bc832d3d2f65a0c9cc4577b01c832c63. The final 25,911-byte run record has SHA-256 dbca54eaedbb043f1325edb4579fe6b6db4bb0de2e159d40088914d763a9fec2. The harness observed the shutdown prompt, confirmation, and cleanup progress, then encountered the known bounded VLM mutex stall. It records forced_after_confirmed_shutdown_stall=true, launcher status 137, orderly_vlm_host_shutdown=false, and state_may_be_incomplete=true. No VLM or Xvfb process remained, the private world was unchanged, no Save World was invoked, and unsaved Lisp state was discarded.

Raw capture provenance and selection

The three selected PNGs passed image- and use-specific review under the museum's screenshot publication policy. They are the minimum cross-system compiler comparison plus one read-only runtime-status screen. None contains source, manual prose, private user data, credentials, mail, network content, or third-party artwork. All other captures and sidecars remain ignored and unreviewed. The selected images are excluded from any project-wide license and do not authorize redistribution of a Genera world, source tree, or other screenshot.

Established

• The two systems support an interactive interpreted-to-compiled replacement workflow and can disassemble the resulting machine-specific function object.
• System 303's traditional-syntax expansion and Genera's Common Lisp expansion can differ while preserving the probe's effect.
• Genera's compiler is split between shared transformations and architecture-specific 3600 or Ivory/VLM back ends.
• Compiler source correspondence supports editor/debugger integration but is not a reversible encoding of unique original source.
• Genera's Garbage Collection command area has four commands, and Start GC is a multi-mode controller rather than a synonym for immediate full collection.
• Genera's development utilities, Common Lisp Developer, and base Common Lisp subsystem are separately declared and versioned systems.

Source-only findings not evident from a command list

• Compile File advertises five compiler labels through dispatch registrations, but invocation still checks for the relevant package and function; label presence does not prove product availability.
• Show Compiled Code can preserve the exact old compiled object presented by a stack frame even after its function name has been redefined.
• Show Expanded Lisp Code distinguishes root/all-level traversal, repeated expansion, compiler-equivalent expansion, style checking, optimizer use, inline expansion, named constants, and constant folding.
• The Genera scheduler is an ordered family of queues, priorities, timers, locks, monitors, events, and waits rather than a single loop hidden behind PROCESS.

Open questions and deferred work

• A compatible System 46 load band is needed for direct release-specific reader, compiler, and disassembler observations.
• A disposable public source file should be compiled on System 303 to compare the complete QC-FILE warning and QFASL workflow with the manual. This run avoided file writes because expression compilation was sufficient for the present claim.
• A Genera world with a configured writable synthetic file host is needed to exercise Compile File, saved warnings, source locators, and editor navigation end to end without involving licensed source files.
• Show Expanded Lisp Code should be repeated using verified Command Processor keyword selection gestures to compare each option against direct MACROEXPAND-1.
• Compiler dispatch labels for optional languages should be tested only in worlds whose installed product and license status are independently established.

Public System 46 representatives

Public System 303 representatives

Licensed Genera representatives

These are evidence-only identities of local licensed files. The files themselves remain untracked.