clasp-developers

clasp

Common Lisp2015–2025

clasp-developers / clasp

clasp

clasp Common Lisp environment

Languages & Compilers Developer Tools

Explore on GitHub Read Hacker News discussions

48Distinct people

95Mentions

1Explicit recommenders

2.8KGitHub stars

REPOSITORY AT A GLANCE

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, 7:56:55 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

UTC ranges include their start and exclude their end. Select a period to filter the source evidence.
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 GitHub

What Hacker News says

9 sources

drmeister·Dec 25, 2018

My group is developing Clasp (github.com/clasp-developers/clasp.git). It's a Common Lisp implementation that interoperates with C++ and uses llvm as the backend. It's something you might want to look at because it could change your options in the following ways: (1) Clasp interoperates with C++ - C++ libraries like graphics and physics engines can be easily exposed within Clasp Common Lisp. (See https://github.com/clasp-developers/demo-expose-bullet-physi...) (2) Clasp uses llvm as the backend - it generates llvm-ir from Common Lisp code and uses link time optimization to link C++ and Common Lisp generated llvm-ir. (3) Clasp uses the Memory Pool System garbage collector, which can be configured to minimize GC pause times to a programmer-defined level. (4) Clasp generates debug info and can be profiled with standard tools like dtrace and

Read the rest

C++ functions, Common Lisp functions and GC functions are all profiled against each other. I'm a professor of Chemistry at Temple University - I'm developing Clasp to design molecules and materials - but it could be applied to a lot of other problems. Caveat: Clasp is not yet as performant as Steel Bank Common Lisp, but it uses the open source and highly configurable Cleavir compiler developed by Robert Strandh and we have incorporated inlining and are currently incorporating type inference. If you want to see a little bit more - I have a 25 min talk up on youtube that I presented a couple of weeks ago at the 2018 llvm developers meeting (https://www.youtube.com/watch?v=mbdXeRBbgDM&feature=youtu.be)

In Creating a Non-Trivial Lisp Game in 2018

ngcc_hk·Dec 17, 2018

Wow!!! This is a wonderful talk. The title is so old school though that need changing. - How I use lisp to fight human aging or - why I choose lisp over python to combat protein generation - my protein generation using llvm was done all by lisp for. Reason The talk is amazing. This one chemistry prof. who seems to be an IT expert but really just start lisp programming by building a lisp interpreter. Wow!!! https://github.com/clasp-developers/clasp And The cando one.

In Lessons Learned Implementing Common Lisp with LLVM [video]

drmeister·Dec 15, 2018

Counterpoint - I implemented a Common Lisp compiler that uses llvm as the back end (https://github.com/clasp-developers/clasp). I've kept up with the versions from 3.6 to 6.0 and I'm about to upgrade to 7.0. I'm not sure why other projects find this difficult but I have noticed that if I get too far behind it does get a bit more difficult. I exposed the C++ API to Common Lisp and write all of the compiler in Common Lisp. The Clang C++ compiler tells me what is broken when I upgrade to a new version of llvm and then I fix it. I talk about it here https://www.youtube.com/watch?reload=9&v=mbdXeRBbgDM&feature... at about 13:30

In The LLVM Compiler Infrastructure

drmeister·Nov 28, 2018

Alternatively - you can choose to program in Common Lisp - an industrial strength language that has been demonstrated in large projects like the QPX flight search engine (Google Flights). For anyone who doesn't know - a big difference that Common Lisp brings to the table is that it has separate namespaces for variables and functions. This may not sound like much but it makes it much easier to write macros (code that writes code) and facilitates compile-time computing. Another big difference between Scheme and Common Lisp is that the Common Lisp specification is _much_ larger and it comes with a much larger collection of standard built-in functions and macros and a standard object-oriented programming facility, among many other things. I know this because I've spent the last six years implementing Clasp (github.com/clasp-developers/clasp)

Read the rest

- a Common Lisp that interoperates with C++ and uses LLVM as the backend. There are several excellent implementations of Common Lisp - Steel Bank Common Lisp is a great place to start.

In Perchance to Scheme (2016)

drmeister·Nov 16, 2018

This is really nice! I wonder how well the ulisp compiler does with optimization - especially for code size. My group is developing Clasp Common Lisp and we use the Cleavir compiler (https://github.com/clasp-developers/clasp and https://github.com/robert-strandh/SICL). Cleavir is a new project to develop a powerful, portable Common Lisp compiler and it could be used to compile lisp dialects.

In GPS mapping application in uLisp

e12e·Nov 8, 2018

I'm a great admirer of Julia, but I doubt it would appeal to those seeking a "true" lisp/scheme. Even if it's has a sane macro system, and much of the same power. You can indeed see s-expressions (search for "s-expression") : https://docs.julialang.org/en/v1/manual/metaprogramming/inde... This nice talk mentions a bit on how Julia is (not) a lisp (if I recall correctly): "Julia: to Lisp or not to Lisp?": https://m.youtube.com/watch?v=dK3zRXhrFZY This might also be of interest: https://tpapp.github.io/post/common-lisp-to-julia/ As well as (maybe) clasp: https://github.com/clasp-developers/clasp

In Chicken Scheme 5.0

lispm·Nov 1, 2018

There are many cases where parsing of Lisp code is necessary. A compiler will need to parse it. A compiler might even generate an internal AST representation (Example: https://github.com/clasp-developers/clasp/blob/master/src/li... ). An interpreter will need to understand the syntax, to be able to traverse code. A tool like a code walker will need to understand Lisp syntax and even may create an AST representation (https://gitlab.common-lisp.net/cl-walker/cl-walker/blob/mast...).

In Fun with Symbolic Derivatives in Lisp

vindarel·Oct 19, 2018

Just to counterbalance and give some hope: projects like CLASP (CL on LLVM) got university funds to development it (and the ecosystem on the way: LSP library,…). https://github.com/clasp-developers/clasp CL is still adopted by universities (for bioinformatics it seems), or innovative firms (Emotiq (blockchain), Rigetti quantum computing,…), and is still used by big ones (https://github.com/azzamsa/awesome-lisp-companies), so why not see fundings in the future…

In This Old Lisp

drmeister·May 10, 2018

This is a very nice web site describing a programming language with unparalleled expressiveness, power and permanence. I am heavily invested in Common Lisp. We are developing a programming environment for designing new materials and molecules called Cando (https://github.com/drmeister/cando) using Common Lisp as a scripting language. Cando is running on Clasp (https://github.com/clasp-developers/clasp), a new Common Lisp implementation that interoperates with C++ and is based on LLVM. What attracted me to the language, after 35 years programming in almost everything else, was how organically it lets one write software and how I don't have to worry about it fading like the next programming fad.

In Common Lisp homepage