If you find Lisp to C compilers interesting, then Common Lisp has a bunch for you. The first CL to C compiler was KCL (Kyoto Common Lisp from Japan in the mid 80s). It is the parent for several other compilers.
Gnu Common Lisp, Embeddable Common Lisp, mkcl, mocl.
There are also attempts at C++ as a target language. See CLASP.
https://www.gnu.org/software/gcl/
https://common-lisp.net/project/ecl/
https://common-lisp.net/project/mkcl/
https://wukix.com/mocl
https://github.com/drmeister/clasp
In Owl Lisp – A purely functional Scheme that compiles to Cclasp-developers
clasp
Common Lisp2015–2025
clasp-developers / clasp
clasp
clasp Common Lisp environment
48Distinct people
95Mentions
1Explicit recommenders
2.8KGitHub stars
What to know before exploring
What it is
clasp Common Lisp environment
GitHub
Where it is used
No documented product use was verified in the last source check.
What people are saying
The GDB JIT interface implementation is seriously flawed. I love GDB - but this causes me a LOT of grief when debugging clasp (Common Lisp implemented using llvm as the backend…
drmeister used a recommendation phrase. One indexed comment matches. This is a phrase match, not a verdict.
No classified warning is attached to this page. Read the discussions before treating silence as approval.
Also in these discussions
- azzamsa/awesome-lisp-companies · linked in 3 of the same discussions
- cando-developers/cando · linked in 3 of the same discussions
- codyreichert/awesome-cl · linked in 2 of the same discussions
Mentioned in the same Hacker News threads. That is not proof they are substitutes.
This week on Hacker News
Nov 7–Nov 14 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/14/2026, 6:01:08 PM UTC.
No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.
Mentions over time
HN mentions by year95 dated mentions
Observed mentions: 2015-02-21 13:20:00 UTC to 2025-07-09 22:57:28 UTC.
Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.
View mention counts and date ranges
| Period | Start (UTC) | End (exclusive, UTC) | Mentions | Submissions | Comments |
|---|---|---|---|---|---|
| 2015 | 2015-01-01 00:00:00 UTC | 2016-01-01 00:00:00 UTC | 11 | 2 | 9 |
| 2016 | 2016-01-01 00:00:00 UTC | 2017-01-01 00:00:00 UTC | 8 | 0 | 8 |
| 2017 | 2017-01-01 00:00:00 UTC | 2018-01-01 00:00:00 UTC | 10 | 0 | 10 |
| 2018 | 2018-01-01 00:00:00 UTC | 2019-01-01 00:00:00 UTC | 9 | 0 | 9 |
| 2019 | 2019-01-01 00:00:00 UTC | 2020-01-01 00:00:00 UTC | 12 | 0 | 12 |
| 2020 | 2020-01-01 00:00:00 UTC | 2021-01-01 00:00:00 UTC | 4 | 0 | 4 |
| 2021 | 2021-01-01 00:00:00 UTC | 2022-01-01 00:00:00 UTC | 12 | 2 | 10 |
| 2022 | 2022-01-01 00:00:00 UTC | 2023-01-01 00:00:00 UTC | 18 | 8 | 10 |
| 2023 | 2023-01-01 00:00:00 UTC | 2024-01-01 00:00:00 UTC | 4 | 1 | 3 |
| 2024 | 2024-01-01 00:00:00 UTC | 2025-01-01 00:00:00 UTC | 4 | 0 | 4 |
| 2025 | 2025-01-01 00:00:00 UTC | 2026-01-01 00:00:00 UTC | 3 | 0 | 3 |
From the project README
An excerpt from the repository, fetched Nov 13, 2026.
Read the project’s introduction
Clasp — Bringing Common Lisp and C++ Together
Clasp is a new Common Lisp implementation that seamlessly interoperates with
C++ libraries and programs using LLVM for compilation to native code. This
allows Clasp to take advantage of a vast array of preexisting libraries and
programs, such as out of the scientific computing ecosystem. Embedding them in a
Common Lisp environment allows you to make use of rapid prototyping, incremental
development, and other capabilities that make it a powerful language.
For more information on using Clasp, see:
Clasp Manual
clbind Documentation
Releases
See Releases for current releases of Clasp. For more information please
see the Release Notes.
Building Clasp
At the moment, Clasp is supported on Linux, Mac OS X and FreeBSD. On these
systems, you should be able to build it from source and you may be able to
install using a package manager. See the Wiki for more information.
In case things go wrong, the quickest way to get help is to either
file an issue, or to chat with us directly.
Building takes a lot of resources. In parallel mode
(:parallel-build t in config.sexp) you need more than 8 GB of RAM
and it will be 1-2 hours build time. If you do not have 8 GB of RAM you can turn off
the parallel build which will then run for a day or so. Make sure to have some
paging space ("swapfile") configured.
There is also docker image here.
Common Lisp Ecosystem Support
Clasp supports the following major components:
SLIME
ASDF
Quicklisp
CFFI
Bordeaux-Threads
Unicode
Post on the issues or contact us if you're interested in changing that.
Contributing to Clasp
We very much welcome any kind of contribution to Clasp, even if it is just bug
finding and testing. A lot can be done all around the project, if you want to
dive into something large. See the Contributing file for the few guidelines
we've set up around contributions.
Reporting Problems
Generally you can report problems in two fashions, either by opening a
New Issue or by chatting with us directly. In both cases, though,
you should have the following pieces handy in order for us to be able to help
you out as quickly and painlessly as possible:
Your operating system name and version.
The branch that you're using of Clasp.
A paste of the build log or failure point that you reached.
Patience.
IRC
Clasp has an IRC channel on Libera called #clasp. If you have questions,
problems, suggestions, or generally would like to just hang out with us devs,
come and stop by!
More on Clasp
For more information on Clasp and the discussion around it, see the following
sites:
Christian Schafmeister's blog
Hackernews
Reddit
Google Tech Talks
ELS2016
Lessons Learned Implementing Common Lisp with LLVM
Acknowledgments
Clasp was supported by:
The Defense Threat Reduction Agency (DOD-DTRA) (HDTRA1-09-1-0009)
The National Institutes of Health (NIH/NIGMS Grant number: 2R01GM067866-07A2)
The National Science Foundation (Grant number: 1300231)
Read the full README on GitHubWhat Hacker News says
8 sourcesIt's a bit ironic that something that uses a lot of macros becomes hard to read. Even the link provided by marquisee in a sibling common seems to have almost a ratio of 2:1 of "signal noise" (or (too) densely coded meta-code) to the amount of "actual" code.
Have there been any (recent) discussions on how to make this stuff friendlier? I mean, one could always just bootstrap lisp on top of ecl[1], like clasp[2] does, and either generate rust code, or just machine code -- but even for plain rust it seems it should be possible to this stuff in a friendlier way?
I'm wondering if it wouldn't be worth it to have a more verbose syntax and/or keywords for this stuff -- it really does appear to me as a usability barrier -- not just because it's new and strange. Reminds me a bit about perl's use of "sigils" which I never quite thought made a lot of
Read the rest
sense personally. I'm firmly in the camp that if you want more syntax than common lisp or smalltalk, you need a really good reason for every bit you add. And while I like a lot of things about rust, I'm starting to wonder if this isn't an area that really needs improving. Kind of like how C++14 tries very hard to get rid of a lot of stuff.
[1] "Embeddable Common Lisp" https://common-lisp.net/project/ecl/
[2] https://github.com/drmeister/clasp
Another project that seem to argue for better abstractions, is clasp, and it's use for (among other things) refactoring c++:
"Clasp: Common Lisp using LLVM and C++ for Molecular Metaprogramming":
https://www.youtube.com/watch?v=8X69_42Mj-g
"Using Common Lisp to refactor C++":
https://www.youtube.com/watch?v=h31pURzgYX8
"Clasp — Bringing Common Lisp and C++ Together":
https://github.com/drmeister/clasp
In Final “STEPS Toward the Reinvention of Programming” Paper [pdf]Clasp is not quite the same, but it can work seamlessly, and compiles to machine code using an LLVM backend [1].
It was created to facilitate using all of the scientific libs in C++ by a chemistry professor for the creation of molecules [2]. It's a big codebase. I'll have to look at LispY C, since on first impression it seems smaller, and I like C!
[1] https://github.com/drmeister/clasp
[2] https://github.com/drmeister/clasp
In LispY CNote SICL is used in CLASP https://github.com/drmeister/clasp (according to CLASP author's talk somewhere)
In Ask HN: What are some examples of beautiful software?So I've done basically the same thing with a few differences:
(1) I chose Common Lisp as the language I would implement
(2) I used C++ template programming to automatically generate wrappers for C++ library functions (like boost::python and luabind) so that I could expose C++ functions directly to Common Lisp. That allowed me to use the llvm C++ API directly.
The project is called clasp -> github.com/drmeister/clasp
Send me a message - we should talk and compare notes.
In No Compiler – On LLVM, and writing software without a compilerSorry to repeat myself, but this is what Clasp [1] does (I am not affiliated with it, I promise).
I am in favor of integrating tightly with a compiler whenever possible, but the selling point of c-amplify is to be independent from any compiler or your existing toolchain. This means that (1) you can work with a in-house proprietary compiler for specific hardware like a game console (author used to develop games) and (2) you code according to some stable C standard and not against a possibly evolving compiler. I suppose the LLVM API is quite stable, but things might break over time.
[1] https://github.com/drmeister/clasp
In Amplifying C (2010)Amplify is mainly used to generate C code that does not need a Lisp runtime. It is used effectively as a smarter preprocessor.
Embeddable Common Lisp (ECL) [1] is an efficient implementation of Lisp that compiles to C. It can be easily used to interface C and Lisp.
Regarding C++, nowadays there is Clasp [2] that is under active development and looks very promising.
[1] https://common-lisp.net/project/ecl/
[2] https://github.com/drmeister/clasp
In Amplifying C (2010)