Editing GNU Guile (section)

==History==
The Guile manual gives details of the inception and early history of the language.<ref name="Manual, History" />  A brief summary follows:

After the success of [[Emacs]] in the [[free software]] community, as a highly extensible and customizable application via its extension (and partly implementation) language [[Emacs Lisp]], the [[Community of practice|community]] began to consider how this design strategy could apply to the rest of the GNU system.  Tom Lord initially began work on an embeddable language runtime named the GNU Extension Language (GEL), which was based on Aubrey Jaffer's Scheme implementation [[SCM (Scheme implementation)|SCM]] (which in turn was based on George Carrette's [[SIOD]]).<ref name="Bader quote SCM" /><ref name="Guile Scheme 1995 quote SIOD" />  Lord convinced [[Richard Stallman]] to make GEL the official extension language of the GNU project, based on the argument that Scheme was a cleaner [[Lisp (programming language)|Lisp]] dialect than Emacs Lisp, and that GEL could evolve to implement other languages on the same runtime, namely Emacs Lisp.  After Lord discovered GEL had a naming conflict with another programming language, he solicited suggestions for a new name.  From several contributions in several [[Usenet newsgroup]]s, Lord controversially chose Guile from a suggestion by Lee Thomas.<ref name="Thomas coin name" /><ref name="Thomas coins name gnu group" /><ref name="Thomas promotes GUILE name" /><ref name="GEL:Important Name Change" />

During the development of Guile (then GEL) and before its public release, the extension language [[Tcl]] was gaining popularity and being pushed as a universal extension language.  Stallman saw Tcl as being underpowered as an extension language, and posted a criticism to the comp.lang.tcl newsgroup, which initiated a [[flamewar]] known as the "Tcl War".<ref>[http://www.vanderburg.org/OldPages/Tcl/war/ Archives of the Tcl War]</ref> Since the public announcement of the Guile project coincided with the Tcl debate, it has become a common misconception that Guile began as a reaction to this.

After the initial release of Guile, development languished for many years, but 2009–2010 saw major improvements,<ref name="2010 improvements" /> and Guile 2.0 was released in 2011 with a new [[compiler]] infrastructure, a [[virtual machine]] implementation, a switch to the [[Boehm garbage collector|Boehm–Demers–Weiser garbage collector]], many improvements to the Guile Scheme language, and other major changes.<ref name="Guile NEWS" />

One of the goals of Guile is to allow other languages to be used alongside Scheme, such that Guile would effectively be a language-neutral runtime environment.  Various attempts at this have been made in past versions: a [[Dialect (computing)|dialect]] of Scheme essentially differing only in its C-like syntax, a translation of [[Emacs Lisp]], a Tcl converter motivated by [[tkWWW]], and something roughly resembling the language [[Logo (programming language)|Logo]].<ref name="An Anatomy of Guile" />  With version 2.0, the project successfully transitioned to a ''compiler tower'' approach, allowing the definition of compilers from one language to another, typically from a higher-level one to a lower-level [[intermediate representation]], and eventually [[virtual machine]] [[bytecode]] or native [[machine code]].<ref name="Manual, Other Languages" /><ref name="Manual, Compiler Tower" />

On 16 Mar 2017, Guile 2.2.0 was released with a new optimizing compiler and high-performance register virtual machine. According to the release announcement by Andy Wingo, real-world programs often showed a speedup of 30% or more with Guile 2.2 when compared to the previous 2.0 series. Guile 2.2.0 also lowered memory usage, sped up the "eval" interpreter, provided better support for multi-core programming, and removed any fixed limit on recursive function calls. It also supported the creation of user-space concurrency facilities that multiplex millions of concurrent lightweight "fibers" and provided a complete Emacs-compatible Elisp implementation, implementing all of Elisp's features and quirks in the same way as Emacs.<ref name=guile_2.2/>

On 16 January 2020, Guile 3.0.0 was released with just-in-time ([[Just-in-time compilation|JIT]]) native code generation for much greater performance. Compared to 2.2, microbenchmark performance is around twice as good on the whole, while some individual benchmarks are up to 32 times as fast.  It also featured support for interleaved definitions and expressions in lexical contexts, native support for structured exceptions, better support for the R6RS and R7RS Scheme standards and many optimizations.<ref name=guile_3.0_news/><ref name=guile_3.0_announce/>

{{Lisp}}

===Emacs integration===
There have been several past unfinished attempts to replace or supplement the [[Emacs Lisp]] extension language with Guile, parallel to the efforts of supporting other languages in Guile.{{Citation needed|date=December 2016}}

With version 2.0 of Guile, a new attempt at implementing Elisp on the Guile compiler tower and replacing Emacs's Elisp implementation with that of libguile has begun and made significant progress through [[Google Summer of Code]] projects.<ref name="BT Templeton Elisp implementation" /> A Guile-based Emacs could offer better execution performance for Emacs Lisp, support new Emacs Lisp language features more easily, make Guile libraries written in other programming languages available to Emacs Lisp code, and allow writing Emacs extensions in other programming languages supported by Guile, all while remaining fully backward compatible with existing Emacs Lisp code bases.

{{As of|2014|10}}, the implementation had reached a stage where Guile Emacs is able to reliably run most Emacs Lisp code. Remaining problems or possible problems involve the different internal representation of Emacs Lisp strings from Scheme strings, the difference between how Emacs Lisp and Scheme treat the Boolean false and empty list objects, Emacs Lisp macros not integrating with Scheme, Emacs Lisp not having been designed for concurrency, and the portability of Guile to platforms supported by Emacs. Other concerns raised by the Emacs community include the relative sizes of the Emacs and Guile communities, and whether it would cause splitting in the community if Emacs were extensible in programming languages other than Emacs Lisp.<ref>{{cite web|url=https://lwn.net/Articles/615220/|title=The future of Emacs, Guile, and Emacs Lisp|accessdate=2025-02-23}}</ref>

At EmacsConf 2024, the relaunch of Guile-Emacs was announced.<ref>{{Cite web |title=Beguiling Emacs: Guile-Emacs relaunched! |url=https://emacsconf.org/2024/talks/guile/ |access-date=2025-02-24 |website=EmacsConf}}</ref><ref>{{Cite web |title=Using Guile for Emacs |url=https://lwn.net/Articles/1001645/ |access-date=2025-02-24 |website=[[lwn.net]]}}</ref>

===GNU Make integration===

[[GNU make]] can be built with support for GNU Guile as an embedded extension language.<ref>{{cite web |title=12.1 GNU Guile Integration |url=https://www.gnu.org/software/make/manual/html_node/Guile-Integration.html |website=[[gnu.org]] |access-date=16 March 2020}}</ref>