SBCL 2.6.7 release adds SB-MANUAL, SIMD extensions, and extensive bug fixes

SBCL 2.6.7 release adds SB-MANUAL, SIMD extensions, and extensive bug fixes

SBCL 2.6.7 brings a new SB‑MANUAL, SIMD extensions, and dozens of bug‑fixes and performance tweaks.

Takeaway: The July 2026 SBCL 2.6.7 release adds a doc‑driven manual (SB‑MANUAL), expands SIMD support to ARM64 and AVX‑512 on x86‑64, and tightens the compiler and runtime across many architectures, making the system faster, more portable, and easier to explore interactively.

SB‑MANUAL: the manual lives in docstrings

The manual is now a contributed module (SB-MANUAL). All sections of the official SBCL reference are stored as docstrings attached to the corresponding Lisp definitions. This enables two powerful workflows:

“The SB‑MANUAL contrib contains the SBCL manual in docstrings of section definitions, which tie together the docstrings of normal Lisp definitions. The manual can thus be explored interactively in the usual way (e.g. with Slime’s M‑.)” – SBCL news.

  • Interactive lookup: With SLIME (or any editor that supports describe/documentation), you can jump to a symbol and instantly view the relevant manual page, just as you would for a function’s docstring.
  • External renderings: The community site https://fixnum.com/ provides heavily linked PDF/HTML/Markdown versions generated from the same source, keeping the online and in‑REPL docs in sync.
  • Markdown subset: Internally the docstrings now accept a limited Markdown syntax, although DOCUMENTATION strips most markup when presenting the text.

“SB‑MANUAL:@FOREIGN‑FUNCTION‑INTERFACE now correctly states that arrays are row‑major (not column‑major).” – bug‑fix note.

Why it matters: Documentation is no longer a separate static artifact; it travels with the code, stays up‑to‑date, and can be queried programmatically. New users can discover the manual without leaving their REPL, and developers can keep documentation close to the implementation.

SIMD support expands to modern CPUs

SBCL’s SB‑SIMD contrib now includes:

  • ARM64 SIMD: Full vector instruction support, contributed by Sylvia Harrington.
  • AVX‑512 on x86‑64: Added by Robert Smith and Arthur Miller, enabling the widest vector registers on recent Intel CPUs.
  • General SIMD extensions: Additional ARM64 and x86‑64 instructions added by Arthur Miller, plus a fix for mis‑compilation of SAP‑REF‑N on ARM64.

These extensions are intrinsic rather than automatic vectorisation. Code must explicitly use the SB‑SIMD API (e.g. simd-pack-256, simd-pack-128, simd-pack-512) to emit vector instructions. However, the compiler now recognises certain high‑level operations (e.g. UTF‑8 conversion, string ASCII checks) and automatically emits the new SIMD routines when the data layout permits it.

“where available, use enhanced SIMD routines for UTF‑8 conversions.” – optimization note.

Impact: Programs that process large binary blobs, text streams, or numeric arrays can achieve substantial speedups on supported hardware with only a few extra lines of code.

Platform‑wide stability and performance improvements

SBCL 2.6.7 ships with a raft of fixes across many architectures (ARM64, x86‑64, PPC, MIPS, LoongArch, RISC‑V). Highlights include:

  • Correct handling of *READ‑SUPPRESS* – warnings about missing internal features are no longer emitted when reading is suppressed.
  • Improved numeric edge‑cases:
    • EQL now treats complex numbers as numeric types.
    • LOG handles quiet NaN inputs more consistently.
    • CONCATENATE no longer warns when called with conditionally known non‑sequence arguments.
  • Compiler optimisations:
    • Constant complex numbers passed to local functions are no longer consed.
    • COUNT now benefits from a wider set of keyword arguments.
    • Redundant instructions removed from SB‑ALIEN:DEREF.
    • Sparse‑set implementation tuned for real‑world workloads.
  • Documentation hygiene: dozens of typos and typesetting errors fixed; the manual now has a dedicated index for declarations.

These changes reduce runtime overhead, eliminate hard‑to‑track crashes, and improve the quality of error messages.

Community insights from Hacker News

  • SIMD curiosity: A commenter asked whether SBCL’s SIMD support is auto‑vectorising or requires explicit intrinsics. The answer is that SBCL provides a low‑level SIMD API; the compiler can automatically use SIMD for some built‑in operations (e.g., UTF‑8 conversion), but most vector work must be expressed via the SB‑SIMD library.
  • Documentation praise: Users highlighted the value of the new SB‑MANUAL module, noting that having the manual in docstrings makes development “much more pleasant.”
  • Portability confidence: Several comments expressed excitement that SBCL continues to ship on a wide range of platforms, from ARM64 to LoongArch, reinforcing its reputation as a production‑ready Common Lisp implementation.

Quick migration checklist for SBCL 2.6.6 users

  1. Load the new contribs:
    (require :sb-simd)   ; SIMD intrinsics
(require :sb-manual) ; interactive manual
  2. Update your code:
    • Replace any reliance on the removed *COMPILE‑PRINT* default (now NIL).
    • Adjust any READ‑SUPPRESS usage that previously triggered spurious warnings.
  3. Take advantage of optimisations:
    • Use COUNT with additional keywords (:START, :END, :KEY) to benefit from the new compiler paths.
    • Prefer CONCATENATE with known sequence types to avoid the earlier warning.
  4. Test on your target architecture: Run the SBCL test suite (make test) on ARM64, RISC‑V, or LoongArch to verify the platform‑specific fixes.

Bottom line

SBCL 2.6.7 is a significant step forward: the manual is now an integral, queryable part of the system, SIMD capabilities have been broadened to modern CPUs, and a host of bug‑fixes and compiler optimisations make the runtime faster and more reliable across an expanding set of architectures. For developers looking to write high‑performance Common Lisp code—or simply to explore the language interactively—upgrading to 2.6.7 is strongly recommended.

Sources