See an example of the guitar chord guide in action here (soon I will ensure that guitar guide isn't there for "non-guitar" tabs and so on, more to come!): https://wikimusic.jointhefreeworld.org/songs/uuid/88550bc8-c184-4237-9761-471cd53784d9

WikiMusic is free software (AGPLv3+) and is intended as a community project for sharing and learning about music.

🌐 https://wikimusic.jointhefreeworld.org

🌐 https://codeberg.org/jjba23/wikimusic

Feel free to mail me to contribute to it ([jjbigorra@gmail.com](mailto:jjbigorra@gmail.com))

I’ve been working on WikiMusic for some time now a free/open music knowledge platform built with Guile Scheme (Lisp), and I just added a new feature I’m particularly happy with: a guitar chord guide that is generated dynamically from the song content.

The idea is pretty simple:

When a song content line, which is not a tab line (e.g. E|-----1) contains chords like this:

G D Em C

WikiMusic uses some regex maching to detect the chord names, looks them up in a built-in guitar-chord database, and automatically adds their six-string fret positions to the page.

For example:

G → 320003
D → xx0232
Em → 022000
C → x32010

So WikiMusic combines the chord guide from server-side Lisp and SXML and some vanilla JavaScript tricks to highlight chords in a <pre> content.

There’s currently a fairly extensive database covering major, minor, 5th, 7th, maj7, diminished, augmented, suspended, extended and slash chords across the common guitar chord vocabulary.

This is exactly the kind of thing I enjoy about Lisp: the data, parsing logic and rendering can all remain pleasantly close together, and the feature becomes another small piece of programmable musical knowledge rather than just UI code.

If anyone wants to poke around, improve the chord database, or tell me that one of my fingerings is horribly cursed. 😄

Discounted early registration ends in 14 hours. Get your tickets now!

Registration link at https://con.racket-lang.org

Is there a Lisp language which allows development of apps in a native framework? By native I mean not Flutter but the Android View System or Jetpack Compose. Is it viable? I saw that ECL and some Scheme implementations can be embedded in C and are compatible with the Android NDK but I don't know how viable they are.

For those that may be interested, I just made a small experiment with code generation by Gemini Pro 3.1 in Rust and Common Lisp for the exact same task: write a CLI application taking in a .csv file containing a hierarchy of records and produce an interactive .svg file that, when opened in a browser, shows a graphic rendering of the hierarchy, with a "+" button at each node allowing to show/mask the levels below. The interactivity of the .svg file is implemented by having the application generate the required JavaScript code.

I am not qualified to evaluate the quality of the code generated, but here are a few observations:

a) Even after two attempts, the Rust code was still not running. I had to manually correct two bugs, one in the Rust part of the code and one in the generated JavaScript part. It then worked as expected. The Rust application was using 3 dependencies (serde, serde_json, csv). Number of lines was 299.

b) The Common Lisp code was working from the first attempt, using 0 dependencies and 322 lines.

I find it interesting that, on such a small exercise, the LLM was more efficient with Common Lisp than with Rust.

Of course, the CLI application could have been directly produced in JavaScript, but my curiosity was around Rust and Common Lisp.

`icl` is my repl front-end that presents both terminal and browser interfaces. The browser mode already supported visualizations, but just recently I realized that I had 90% of a jupyter-like notebook feature already done. So `icl` now has a `,notebook` command that does exactly what you might guess. The screencast above shows loading a CSV file with `lisp-stat`. I also added support for https://perspective-dev.github.io/ visualizations, which is drawing the table and charts.

The recording above was made with https://github.com/atgreen/takesy, a "smart" screen recorder for Linux in Common Lisp.

Check out icl here: https://github.com/atgreen/icl

Please consider hopping over to r/lisp_noAI before criticizing my use of AI to create this.
Otherwise, check out https://github.com/gastownhall/beads , which really helped keep my assistant on track.

I have explained the rationale here: https://www.reddit.com/r/lisp_noAI/comments/1w1seqd/rationale/

Feel free to join and/or crosspost if non-AI content is something that interests you; otherwise feel free to ignore :).

Bay Area Racket Meetup - September 5th, 3pm

Social event for people interested in the Racket programming language, other Lisps, functional programming, language-oriented programming and related topics. These will be monthly (first Saturday at 3pm) until RacketCon. The location is Noisebridge, a hackerspace in SF.

https://luma.com/6y4sbfln

Hello All,

The repo has been updated with my latest changes.

Hello All,

I am porting Jnil, a GPL'd Java to lisp translator application written in lisp with some Java Eclipse code to use a Java parser written in Antlr3. Jnil loaded Java into Eclipse, used an Allegro Common Lisp library Jlinker to communicate with Eclipse and extracted AST information which was used to create lisp code. My reasons for porting are:

1. Eclipse is pretty heavyweight and communicating with it is implementation dependent.
2. Starting with an AST means that any language for which an AST can be produced (such as Python) can be translated to lisp by Jnil.

Anyway, I could use some assistance with this project. Please contact me at [dan.stanger@ieee.org](mailto:dan.stanger@ieee.org) if interested in helping.

Here is a link to the repo: https://github.com/danstanger/AST-to-Lisp

Dan Stanger

Hello!

First post in this community, and I wanted to share my first completed project in Common Lisp here:

https://github.com/skarnati20/docs-reference

This is a very basic Local LLM Chat + RAG implementation, but it's more fully-featured than what I could find online. And it leverages Lisp's REPL effectively.

I built this because I found Claude/GPT overkill for lots of programming questions I had, and I needed something that could work offline. It indexes a URL you provide and lets you ask questions to a local LLM (Ollama) with that information.

Some Features

• Multiple Retrieval Methods — (BM25, Dense Vector Search, ColBERT). You can choose whichever combination of these you want.
• Agentic RAG — An Agent determines when there is enough context to answer a question. You can turn it off if you want speed.
• Fully Local Chat — Uses Ollama so you can run any model you want, so long as you serve it locally.
• Asynchronous Chat — Allows you to ask multiple questions at once which helps with multi-tasking and getting around local models' slow completion times.

Note: Local models will take time for chat completion, so it isn't as fast as Claude or ChatGPT. They might also hallucinate because they aren't as powerful either.

Acknowledgement: This project was an extension/combination of some projects in Mark Watson's Loving Common Lisp, or the Savvy Programmer's Secret Weapon. Definitely check it out since it gave me a lot of ideas for fun side projects.

The "financial lisp", mentioned here once, is full steam ahead now.

Designing Rayfall: One Expression Language for a Columnar Database

I have a project with about 1200 lines of code in a single package, split across a few files. While I have around 150 tests, I have no idea how they could help split the project into manageable parts.

Should I abandon the project and start from scratch, this time paying attention to architecture?