CHICKEN 6.0.0 moves R7RS and Unicode into its core

Why it matters

CHICKEN 6 modernizes a 26-year-old compiler without abandoning its compile-to-C design, but its Unicode and R7RS gains require real migration work across existing code and eggs.

CHICKEN 6.0.0 moves the full R7RS Small standard and UTF-8 strings into the core of the Scheme implementation that Felix L. Winkelmann started in 2000, while changing enough foundational APIs to require porting work from CHICKEN 5.

The release notes do not establish when the final release was published. The safer reading is that 6.0.0 is the culmination of a public development cycle that began well before this week's discussion. Peter Bex published the first 6.0.0 prerelease in December 2024, asking developers to begin testing and porting their extension libraries, known as eggs.

For Winkelmann, the release extends a technical bet he made 26 years ago: Scheme could gain portability by compiling into straightforward C rather than binding itself to a narrow set of machines or a large runtime. In his July 20th, 2000 announcement, he described an implementation that was small, easy to extend and capable of producing standalone executables. CHICKEN's current manual still centers that model. Its compiler emits portable C, while its interpreter supports interactive development and scripting.

Winkelmann developed CHICKEN through 2007 before asking its community to assume responsibility for maintenance in early 2008. He remained active, and CHICKEN's maintainer roster still identifies him as its author and a core hacker alongside Peter Bex, Evan Hanson, Kooda and megane. Other contributors operate the package, testing, documentation and infrastructure services that keep a language implementation usable long after its original author stops carrying it alone.

Standards move into the core

The defining change in 6.0.0 is the decision to make every module specified by R7RS Small available in CHICKEN's core system. Developers previously relied on an external R7RS egg for that layer of standards compatibility.

That consolidation affects where familiar procedures live. Functions including call/cc, parameterize, open-input-string and get-output-string have moved from (chicken base) to (scheme base). case-lambda now resides in (scheme case-lambda), while define-record-type has moved into (scheme base) and produces generative record types to match R7RS behavior.

CHICKEN also removed module aliases for several older SRFIs already covered by R7RS. The compiler and interpreter option formerly named -r5rs-syntax is now -r7rs-syntax. Older R4RS and R5RS compatibility modules have been renamed under the (scheme ...) convention.

These changes make standards-conforming code easier to bring into CHICKEN over time. They also force existing applications to stop depending on CHICKEN-specific locations for procedures that now belong to standard modules.

UTF-8 changes the runtime contract

The other foundational shift is CHICKEN's conversion of its internal string representation to UTF-8. Strings are now Unicode-capable, file input and output can specify UTF-8 or Latin-1 encoding, and string locatives are indexed by code point rather than byte.

That work reaches beyond text display. CHICKEN replaced (chicken blob) with (chicken bytevector), which provides R7RS-compatible bytevector operations. Bytevectors are now equivalent to SRFI-4 u8vector values, and the old blob reader syntax has been removed in favor of #u8(...) and #u8"..." forms.

Procedures including file-read, file-write and random-bytes now require bytevectors instead of accepting strings. CHICKEN added binary input and output port constructors along with bytevector read and write procedures. The result is a clearer separation between encoded text and raw bytes, a distinction that applications could previously blur.

That clarity carries migration costs. Code that treated strings as byte containers must change, while code that indexed strings under the assumption that one byte represented one character needs review. CHICKEN's porting guide groups Unicode, blobs, bytevectors, port encodings, moved procedures and removed APIs among the central issues for CHICKEN 5 users.

A broader systems update

Version 6.0.0 also revises CHICKEN's operating-system and C interfaces. Process functions such as process-fork, process-run and process now return process objects instead of bare process identifiers. Callers can obtain status information and ports through record accessors, while waiting and signaling functions continue to accept either an object or a PID.

File locking in (chicken file posix) now uses flock(2), operates over whole files and is described in the release notes as thread-safe. The foreign-function interface can pass complex numbers, C structs and unions directly as arguments and results. Strings and symbols sent to foreign code are no longer copied, meaning mutations performed by C code are visible from Scheme.

The build process has changed as well. A configure script now prepares the source before make, bringing CHICKEN closer to conventional Unix build practices. The minimal Windows build has been dropped in favor of a POSIX-shell-based toolchain, and the build can use zig cc as a replacement C compiler and linker. Compiler optimization levels can now enable closure reuse and sharing to reduce allocations.

Winkelmann's interest in keeping Scheme close to C has continued alongside the CHICKEN 6 work. In 2024, he introduced CRUNCH, a compiler for a statically typed R7RS subset that runs on CHICKEN and emits portable C99. He described it as a route to compact programs for games, virtual machines, embedded systems, operating-system components and performance-sensitive libraries.

CHICKEN 6 gives that work a standards-oriented base while preserving the original architecture. The release does not replace the project's compile-to-C identity with a new runtime or platform target. It updates the assumptions around text, modules, records, processes and foreign data so that the same architecture can carry code written against a newer Scheme standard.

The immediate work now falls to maintainers of applications and eggs. CHICKEN 6 removes deprecated procedures, relocates core bindings and changes data representations that sit beneath file handling and foreign calls. The upside is a smaller gap between portable R7RS code and CHICKEN code. The price is a major-version migration that developers will have to treat as a port, rather than a routine compiler upgrade.