Chicken (programming language)

Chicken (programming language)
Name	Chicken
Paradigm	Multi-paradigm: functional, imperative, metaprogramming
Designer	Felix Winkelmann
Developer	The Chicken Scheme Team
First appeared	2002
Typing	Dynamic, strong
License	MIT License
Influenced by	Scheme, Lisp
Website	chicken.example.org

Chicken (programming language) Chicken is a lightweight, practical Scheme implementation and compiler that targets C as a portable backend. It combines a high-level Lisp-derived language with an emphasis on portability across Unix, Linux, FreeBSD, OpenBSD, macOS, and Windows platforms, and integrates with toolchains and libraries from GNU Project, BSD ecosystems and various vendor ecosystems. Chicken's design enables interoperability with existing C standard library components and supports deployment in embedded, desktop, and server environments influenced by projects like SQLite, Nginx, and Apache HTTP Server.

History

Chicken originated in the early 2000s, emerging from discussions among contributors associated with Scheme communities and implementers influenced by Racket, Guile, and historical systems such as MIT Scheme and Gambit (programming); key development was driven by individuals including Felix Winkelmann and collaborators connected to open source projects and events like EuroPython and FOSDEM. Early releases focused on producing efficient C output to leverage compilers from GCC, Clang, and vendor toolchains used in projects like Debian and Fedora, while adoption grew through packaging in distributions such as Debian, Ubuntu, Arch Linux, and Gentoo. Over time the project engaged with standards bodies and community efforts related to R5RS and R6RS discussions and drew influence from porting efforts seen in OpenBSD and NetBSD ports.

Design and Implementation

Chicken compiles Scheme source to portable C code and then uses system toolchains such as GCC, Clang, and MSVC to produce native binaries, leveraging object formats like ELF and PE; this approach echoes strategies used by Erlang/BEAM and Haskell compilers that emit C or intermediate code. The runtime implements a generational garbage collector inspired by designs in CPython and JVM implementations, and supports foreign-function interfaces (FFI) that permit direct calls into libraries like libc, OpenSSL, and GLib. Compilation stages integrate with build tools and standards exemplified by Autoconf, CMake, and make while generating artifacts compatible with package managers used by Homebrew, Chocolatey, and RPM Package Manager ecosystems.

Language Features

The language implements a R5RS-style core with macros, hygienic macro systems similar to those in Racket and macro facilities comparable to Common Lisp's CLOS-adjacent techniques. Features include first-class continuations (call/cc) from historic Scheme semantics, tail-call optimization following Lambda Calculus-inspired functional implementations, and a module and record system compatible with libraries influenced by SRFI proposals such as SRFI 9 and SRFI 0. Chicken also provides asynchronous and concurrency primitives that interoperate with event libraries used in libevent and libuv, and offers facilities for metaprogramming and code generation used in projects comparable to Yacc/Bison wrappers and ANTLR integrations.

Tooling and Ecosystem

The Chicken ecosystem centers on the "eggs" packaging system, analogous to package systems in Python and Perl CPAN, and mirrors practices from Node.js's npm and RubyGems ecosystems; the eggs repository hosts libraries for web frameworks, database drivers (inspired by adapters for PostgreSQL, MySQL, and SQLite), and GUI bindings that interface with GTK+ and Qt. Development tooling includes an interactive Read-Eval-Print Loop (REPL) comparable to GHCi and Python REPL, debuggers and profilers leveraging GDB and Valgrind, and integrations with editors and IDEs such as Emacs, Vim, Visual Studio Code, and JetBrains products. Continuous integration and deployment patterns follow workflows used in GitHub Actions, GitLab CI, and Travis CI adaptations, enabling packaging for ecosystems like Docker and Flatpak.

Performance and Portability

By emitting C and relying on mature compilers like GCC and Clang, Chicken attains performance characteristics competitive with other dynamic language implementations such as Lua and PyPy in certain workloads, while maintaining portability across CPU architectures supported by toolchains used in ARM, x86_64, and PowerPC deployments and in operating systems like Android and iOS via cross-compilation techniques popularized by Buildroot and Yocto Project. Benchmarking comparisons reference methodologies used in research appearing at venues like ACM SIGPLAN and USENIX to evaluate startup time, peak throughput, and memory overhead against implementations such as Chez Scheme, Gambit, Chicken Scheme (disallowed link) — note: omitted — and other language runtimes.

Adoption and Notable Projects

Chicken has been used in web applications, tooling, and scripting where projects draw on stacks involving SQLite, PostgreSQL, NGINX, and Redis integrations, and has powered utilities and libraries distributed through GitHub and GitLab repositories maintained by contributors from communities frequenting Stack Overflow and mailing lists like those on GNU Savannah and SourceForge. Notable uses include small-scale web services, command-line tools, and extensions to larger systems akin to plugins for GIMP, Vim, and Emacs packages, as well as academic projects and demonstrations at conferences such as ICFP and PyCon that explore language implementation and interoperability.

Category:Scheme implementations