HackerReposA FIELD GUIDE TO OPEN SOURCE
ProSponsor the shelf♧ 0
← Back to top all-time
azzamsa
awesome-lisp-companies
Languages & Compilers2018–2026
azzamsa / awesome-lisp-companies

awesome-lisp-companies

Awesome Lisp Companies

10Distinct people
58Mentions
0Explicit recommenders
655GitHub stars
REPOSITORY AT A GLANCE

What to know before exploring

What it is

Awesome Lisp Companies

GitHub

Where it is used

No documented product use was verified in the last source check.

What people are saying

No recommendation phrase was found in the indexed comments.

No classified warning is attached to this page. Read the discussions before treating silence as approval.

Also in these discussions

Mentioned in the same Hacker News threads. That is not proof they are substitutes.

This week on Hacker News

Nov 9–Nov 16 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/16/2026, 7:01:10 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 year58 dated mentions

Observed mentions: 2018-07-02 09:46:02 UTC to 2026-07-17 23:27:03 UTC.

0510152018-01-01 00:00:00 UTC to 2019-01-01 00:00:00 UTC (exclusive): 2 mentions; 0 submissions, 2 comments20182019-01-01 00:00:00 UTC to 2020-01-01 00:00:00 UTC (exclusive): 3 mentions; 0 submissions, 3 comments2020-01-01 00:00:00 UTC to 2021-01-01 00:00:00 UTC (exclusive): 3 mentions; 1 submissions, 2 comments2021-01-01 00:00:00 UTC to 2022-01-01 00:00:00 UTC (exclusive): 13 mentions; 1 submissions, 12 comments2022-01-01 00:00:00 UTC to 2023-01-01 00:00:00 UTC (exclusive): 11 mentions; 0 submissions, 11 comments20222023-01-01 00:00:00 UTC to 2024-01-01 00:00:00 UTC (exclusive): 8 mentions; 0 submissions, 8 comments2024-01-01 00:00:00 UTC to 2025-01-01 00:00:00 UTC (exclusive): 12 mentions; 0 submissions, 12 comments2025-01-01 00:00:00 UTC to 2026-01-01 00:00:00 UTC (exclusive): 4 mentions; 0 submissions, 4 comments2026-01-01 00:00:00 UTC to 2027-01-01 00:00:00 UTC (exclusive): 2 mentions; 0 submissions, 2 comments. Incomplete calendar period.2026*

* An incomplete calendar period is marked with an outlined bar. Its count is not directly comparable with a full period.

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.
PeriodStart (UTC)End (exclusive, UTC)MentionsSubmissionsComments
20182018-01-01 00:00:00 UTC2019-01-01 00:00:00 UTC202
20192019-01-01 00:00:00 UTC2020-01-01 00:00:00 UTC303
20202020-01-01 00:00:00 UTC2021-01-01 00:00:00 UTC312
20212021-01-01 00:00:00 UTC2022-01-01 00:00:00 UTC13112
20222022-01-01 00:00:00 UTC2023-01-01 00:00:00 UTC11011
20232023-01-01 00:00:00 UTC2024-01-01 00:00:00 UTC808
20242024-01-01 00:00:00 UTC2025-01-01 00:00:00 UTC12012
20252025-01-01 00:00:00 UTC2026-01-01 00:00:00 UTC404
2026 (partial)2026-01-01 00:00:00 UTC2027-01-01 00:00:00 UTC202

What Hacker News says

13 sources
There are some jobs. We see announces on /r/lisp, Twitter, LinkedIn… sometimes very informal ones. Some companies still pick up CL, for instance: https://github.com/azzamsa/awesome-lisp-companies/ (it's possible that Ravenpack is still hiring?). A good way is of course to learn CL and have something ready to show. Some announces don't require a (commercial) Lisp background though, they seek high-level engineers. Another way is to use CL for yourself, at current job or not. There's plenty of space for that. I use it for new services, instead of extending a Python aging monolith (DB access, FTP connection, XML parsing of a big dataset, a simple web frontend,…). I have even been doing live reloads for a year, installing new libraries while the app is running, and it's been a joy so far. I found one bug (with Sentry alerts of course), because
Read the rest
I used = where a number could be nil. So I use `equal`. I am happy, I am productive, deployment is easy and the app is fast.
In Common Lisp
This website (and all the author's libraries) was such a refresher. It has been important for me to not run away from CL (again). At that time, the "official" website, the first Google result for CL looked like this: https://web.archive.org/web/20160305135106/https://common-li... Fortunately, they revamped it circa 2018: https://common-lisp.net/ (work mainly due to @mmontone if I'm not mistaken). Since then, the Cookbook was expanded with useful content (it was kind of hard to find up to date information online, on even simple matters like how to build a binary) and we got some useful lists too, like https://github.com/CodyReichert/awesome-cl and a list of (current, existing) companies: https://github.com/azzamsa/awesome-lisp-companies/ Hopefully it's easier than ever to have your questions answered and start hacking in Lisp! Another very
Read the rest
helpful resource by Fernando was his state of CL ecosystem: https://borretti.me/article/common-lisp-sotu-2015 It really helped have an overview of the ecosystem, pick libraries and work on consolidation. I compiled one for 2020 here: https://lisp-journey.gitlab.io/blog/state-of-the-common-lisp... (ps: yes people, you can avoid Emacs and use VSCode to have a good experience! and even Atom, Jupyter notebooks and more. See https://lispcookbook.github.io/cl-cookbook/editor-support.ht...)
In Common Lisp
A lot has gone wrong in terms of achieving high adoption, but specifically about something going wrong with rallying around CL, I don't think anything went wrong. No more are Maclisp, Interlisp, Lisp Machine Lisp, Zetalisp, Franz Lisp, Portable Standard Lisp, Spice Lisp... They were all slain or subsumed by Common Lisp. (You might have seen Franz elsewhere in this thread; rather than continuing it Franz, Inc. just developed Allegro Common Lisp separately. Spice Lisp meanwhile changed to become a CL implementation, became CMUCL, which was later forked into the now most popular implementation SBCL.) Le Lisp/ISLisp are interesting European competition that didn't fall in line, but I don't ever hear about them, I only know they exist/existed, they might nowadays be effectively dead for all I know. Emacs Lisp is probably the biggest success in
Read the rest
not caving to CL. Not big enough to constitute anything "going wrong" though. I think your perception is wrong in two ways. First is the idea that Scheme and Clojure are somehow "variants" or "dialects" of Lisp. Scheme was never a Lisp dialect, it was instead described as "a LISP-like language, SCHEME, based on the lambda calculus, but extended for side effects, multiprocessing, and process synchronization." Also notice neither Scheme nor Clojure even have "Lisp" in their name, unlike all those other languages that got eaten by CL. "Lisp" meant something, and "Common Lisp" unified that meaning and I think deserves to be synonymous with "Lisp"; many writers have treated it that way. But Common Lispers are giving up that fight, because it's tiresome but also an understandable confusion not helped by Scheme or Clojure's attempts at capitalizing on some primordial idea about the good name of Lisp or whatever drives them to associate with the term. (#lisp in Freenode used to be only for Common Lisp, now in Libera #lisp is for all Lisp-likes and CL has its own channel.) Anyway, Scheme and Clojure have happily had their own evolution and separate largely incompatible s-expressions. I don't think their continued existence is a flaw against CL any more than another random programming language would be. One aspect of Clojure that might sting a little is that its entire reason for existing was because the author couldn't win political fights about having CL in production instead of the JVM. The second way I disagree with your perspective is on prevalence. Scheme has had some success in teaching (mostly thanks to SICP) though Common Lisp was/is also used similarly at various places, however I think that's hurt [Common] Lisp more than anything. (Basically CL gets taught like Scheme, and so whether CL or Scheme is used students come away thinking they "know Lisp" without ever really having seen its OOP power, its handling of types, its condition system, its easy-to-define macros, let alone the trivial things like LOOP or SETF that make imperative programming possible and easy. It's like C++ classes that teach it as C-with-classes, but worse.) Scheme has also had success as GNU's official extension language (with Guile, which goes a ways beyond standard Scheme to be useful) and you see Scheme pop up in places like GIMP plugins. Racket seems like the most popular modern Scheme, aimed at being suitable for real work, but it has gone waaaay beyond standard Scheme and slowly seems to be becoming as large as CL. Real stuff is presumably made with it, not just education stuff or scripts or extensions, but I'm less familiar with what's going on. It may yet eat CL's lunch. Clojure of course has been a rising star and has enjoyed a lot of success in real stuff. It's popular, it's fashionable, and in terms of projects-per-second your perception is probably right that it's more widely used than CL right now. Where I would draw disagreement is in total pound-for-pound code that's Out There. CL has the benefit of decades of existence, so for example https://www.ptc.com/en/products/creo/elements-direct has been developed for a long time and is made of several million lines of CL code, and that's just one project. If you only used "active" (i.e. someone executed it over last month) code perhaps there's enough Clojure out there now to be an interesting race though there's no way to really tell; if you allow for all the CL that has been written and is no longer run, I don't think there's any contest, CL has such a rich history. (A random application being Mirai https://en.wikipedia.org/wiki/Mirai_(software) with demo https://www.youtube.com/watch?v=-IRsYGfr4jo -- has there ever been a 3D modeling program written in Clojure? Will there ever be?) https://github.com/azzamsa/awesome-lisp-companies is an ongoing collection of companies known to be using CL. In terms of "industries", right now quantum computing companies seem particularly drawn to CL. Symbolic math historically also, with Maxima and Axiom being still-working/developed code bases. (The latter is a million lines of literate CL.) But drawing on legacy again rather than last-few-years stuff, an old quote by Kent Pitman seems relevant: "Please don't assume Lisp is only useful for Animation and Graphics, AI, Bioinformatics, B2B and E-Commerce, Data Mining, EDA/Semiconductor applications, Expert Systems, Finance, Intelligent Agents, Knowledge Management, Mechanical CAD, Modeling and Simulation, Natural Language, Optimization, Research, Risk Analysis, Scheduling, Telecom, and Web Authoring just because these are the only things they happened to list." We can of course add more things to the list if that would help, like Mars Rovers or video games, https://news.ycombinator.com/item?id=9510945 has a few more, in recent news I learned about https://www.reddit.com/r/Common_Lisp/comments/osnsgz/intels_... and https://github.com/shop-planner/shop3 was open-sourced in 2019. Is it dominant in any area (besides maybe quantum)? I don't think so. Against Clojure though I'm sure it dominates some areas while not at all winning at others, it'd be a case-by-case thing. Common Lisp is in a lot of places all over the world (it's had quite a legacy in Japan even), but not the most fashionable stuff, so it's also understandable that many people haven't heard about it, realized they're using it, or heard people talking about it. (Edit: one final example that's not too esoteric, if people have ever used pgloader for Postgres, it may surprise them to learn it's written in CL, and even more than that, used to be written in TCL and later Python before moving to CL...)
In Some thoughts about raising the profile of Lisp
For those interested, today we have a source which references some present companies that use CL in production. It is by no means an official one, we collect data when we find it, but it makes our answer to "who uses CL?" way better than only 2 years ago: https://github.com/azzamsa/awesome-lisp-companies/ Google (still, with ITA Software, people from Google contribute heavily to SBCL), Intel (for the Tofino programmable chip https://allegrograph.com/press_room/barefoot-networks-uses-f...), all quantum computing companies (the new AI?), Boeing, web companies (the new OSS app Screenshotbot), cloud providers (keepit), music products (the awesome ScoreCloud app), banks (russian Sberbank), financial analytics (Ravenpack), etc. Several of them are still hiring.
In Lisping at JPL (2020)
> anyone uses it in industry we just don't get the news. Now we have some pointers: https://github.com/azzamsa/awesome-lisp-companies/ There are big names and companies in a diversity of areas. > lack of intuitiveness towards Julia syntax that's a great thing about Lisp > Lisp could never break out into the mainstream. yes it did in the 80s, it has been on top 3 of the Tiobe index for many years. It's ranked 25 this month, before Rust, Julia, Haskell, Scala, Lua, Elixir, Clojure… funny right? Yes the Tiobe index doesn't measure very meaningful stuff. Why not Julia and why Lisp? I collected some feedback: https://gist.github.com/vindarel/15f4021baad4d22d334cb5ce2be... The REPL, the static checks, the binaries/deployment options, the stability, the load times, the ecosystem… are weaker in Julia. This quote makes me wonder: > This means the
Read the rest
re is an upper bound to how good the editing and refactoring tooling will be. I suspect the best will be a little below Pythong's tooling, because Python's class helps in disambiguating methods.
In Julia and the Reincarnation of Lisp (2020)
> magic I'd say yes, this, though you don't actually manipulate a proper AST, but a list (tree) of program instructions. An AST would be given by a "code walker". Plus, the syntax is small and coherent, the language is stable, the syntax makes it straightforward to add new language constructs that would need a language release for another classical language. With most implementations of Common Lisp, you code against a live image, so you get instant feedback: compile a function with a keybinding, see compiler warnings or errors instantly, try it right away in the REPL (no process had to restart), get an interactive debugger on an error, fix it and resume the execution from a chosen frame (no stack unbinding), inspect objects, change a class definition and have existing objects being (lazely) updated, given rules in the standard that you ca
Read the rest
n control… when ready, build a binary, and deploy. Today, SBCL's compile-time type-inference warnings are very helpful. Of course, some companies use CL in a million-sized codebase (if that helps as a counter example): Google (ITA software), SISCOG (underground and rail transport optimisation), ACL2 (industry-strength theorem prover)… https://lisp-lang.org/success/ https://github.com/azzamsa/awesome-lisp-companies (disclaimer: these resources are not complete)
In Lispsyntax.jl: A Clojure-like Lisp syntax for julia

MAKE YOURSELF AT HOME

A few shortcuts

/
Search the collection
?
Open this guide
Esc
Close dialogs and navigation

Your saved repositories and interests stay in this browser.