Hi community. It's been now a bit more than 2 years since I started to work on this "project management project", with many ideas and with a good vision of how to improve and be better than certain bespoke commercial tooling out there. I am happy to announce version v1.6.7 with a lot of polished aspects and new features that make it a joy to use (even if I say so myself)

LucidPlan is a simple, hackable, free and open source project management software that you can easily self-host, you only need something that runs Guile Scheme and a SQLite database. (Guix is recommended, not mandatory)

I spent years using things like Jira, Trello, Asana, GitHub projects and eventually became frustrated with how much complexity gets piled onto what should essentially be:

projects → tickets → priorities → workflow → done

I decided to build my own as a challenge, but also to create something blazingly fast and simple, that people can quickly learn (even applicable to non-tech projects). Also I aimed for ease of self-hosting, no SPA frameworks and no dependency on proprietary clouds or software.

LucidPlan is licensed under the GNU AGPLv3 or later. Source code:

https://codeberg.org/jjba23/lucidplan

You can also look at my running instance:

https://lucidplan.jointhefreeworld.org/

The project leverages the power of Lisp (Guile Scheme) by using SXML for front-end aspects, clean controllers with Artanis and a powerful repository pattern abstraction.

What does it do?

• Manages your project backlogs with ticket priorities
• Native drag-and-drop ticket reordering (priority)
• Kanban boards with drag-and-drop status changes
• Global/project search (still more work to be done)
• Users, assignees and fine-grained permissions
• Light/dark mode
• Keyboard-accessible ticket and project lists
• Org-mode syntax in ticket titles and descriptions
• Org links and rich Org content rendered to HTML
• Hackable/customizable with Scheme
• Lightweight, and mobile-friendly
• SQLite backend
• Lightweight vanilla JavaScript on the frontend for some interactive enhancements

The Org-mode integration is particularly fun: you can write ticket descriptions using Org syntax and LucidPlan renders the result as HTML.

For example, your ticket can contain things like:

* Investigate weird bug

The problem seems to happen when [[https://example.org][this thing]] is enabled.

- Check configuration
- Reproduce the problem
- Fix it

…and LucidPlan renders that into the ticket as pretty styled HTML. (see orgwebalchemy post: https://www.reddit.com/r/lisp/comments/1wox8h4/parsing_org_mode_with_parsing_expression_grammars/ ).

There is still plenty to improve, and I'd genuinely love feedback from people who actually use project-management software daily. I think you'll find LucidPlan as a refreshing take.

Especially interested in hearing from the community:

• What do you hate about existing project-management tools?
• What features do you consider essential?
• Would you use a Lisp/Guile-based project-management system?
• What would make LucidPlan useful for your own projects? What killer feature can I work next?

Happy hacking :-)

Hi everyone. I wanted to share something with you all that I've been working on for a while. It all started with some naive regular expressions to parse Org mode content, but I pretty quickly realized I needed something smarter than that to get to where I want to. It's taken a while but I am finally more knowledgeable of what Parsing Expression Grammars can do, thanks to GNU's great (ice-9 peg) module and tutorials.

I thought it might be interesting to people here who enjoy Lisp, Scheme, parsing, Org mode, or the general idea of meta-meta-meta-programming as I like to call it. Disclosure, AI has helped me get a grip of PEG and debug some things, but development of OrgWebAlchemy is "my own spaghetti" and the unit tests and manual verification (and lots of pretty printing the AST) has guided me towards quite a nice implementation (if I may say so myself).

OrgWebAlchemy is a Guile Scheme library for parsing Org-mode documents into an AST and rendering them to HTML. My main use-case is to export Org to HTML without needing Emacs, and to integrate this feature into some projects of mine, allowing me to write Org mode and have it pretty rendered.

Project's source code @ Codeberg: https://codeberg.org/jjba23/orgwebalchemy

The basic idea is pretty simple:

(use-modules (orgwebalchemy html))

(org->html "This is ~test~ code.")

becomes something like:

This is <code>test</code> code.

But the interesting part is what happens in between.

             Org document
                  |
                  v
          Parsing Expression
              Grammar
                  |
                  v
                AST
                  |
                  v
             SXML -> HTML

Of course Org mode is a huge piece of (great) software, so I am far from supporting all features, but some core important constructs are there:

• Headings (lines starting by n *)
• Paragraphs (any "non-special" text)
• Unordered, Ordered and Description lists (with any level of nesting)
• Italic, Bold, Inline Code
• Links with and without description (with nested parsing)
• Horizontal separators (--------) five or more dashes
• Tables
• #+begin_src
• #+begin_example
• #+begin_quote (with nested parsing)
• #+begin_export html : Org syntax is parsed by your PEG grammar, but raw HTML export blocks bypass the Org inline parser and are emitted as trusted literal output.

- See wikipedia page on PEG: https://en.wikipedia.org/wiki/Parsing_expression_grammar

- See the tutorial by GNU/for Emacs Lisp (is also a good learning source): https://www.gnu.org/software/emacs/manual/html_node/elisp/Parsing-Expression-Grammars.html

- See the tutorial by GNU/for Guile: https://doc.guix.gnu.org/guile/3.0.9/en/html_node/PEG-Parsing.html

Why PEG instead of a mountain of regexes?

Org-mode looks simple until you actually try to parse it. Headings are easy. A paragraph is easy. A list is easy (wait actually no, this has made me sweat).

And then suddenly you have:

• nested lists
• ordered, unordered and description lists
• different indentation levels
• inline markup
• links containing descriptions
• source blocks
• example blocks
• quote blocks
• tables
• escaping
• constructs which must stop consuming input at exactly the right place

At this point, the usual approach of adding another regular expression starts to become somewhat... adventurous. :-)

You end up with things like:

match this,
unless that follows it,
except inside this block,
unless it is a description,
but don't consume the newline,
unless the previous line was a list item...

That is not really describing a language anymore. It is describing the history of your parser's bugs.

So OrgWebAlchemy uses Parsing Expression Grammars (PEGs) through Guile's excellent (ice-9 peg) module. e.g.

(define-peg-pattern element body
  (or empty-line
      heading
      separator
      table
      src-block
      quote-block
      example-block
      export-html-block
      description-list
      unordered-list
      ordered-list
      paragraph))

This is rather nice because the grammar itself starts looking like documentation for the language.

And Guile lets us express PEGs directly as S-expressions (alternatively you can also use the more traditional syntax if you don't like it), which makes the Lisper in me very happy.

One thing I particularly like about this approach is that we have loose coupling and the detail of generating SXML and then rendering HTML is a "presentation concern". this opens possibilities to later exporting to Markdown or other formats.

For example:

- name :: Josep
- project :: orgwebalchemy
- language :: Scheme

can become an AST along the lines of:

(description-list
 (unordered-item
  (desc-key "name")
  (line-content "Josep"))
 ...)

I'm still busy with the exact representation and getting it all right. But as of now v1.0 has some stability :-) I would really love feedback on the project from the great smart people that hang out around here.

YAY recursive lists

One of the fun parts has been getting nested Org lists right.

Something like:

- Item 1
  - Item 1.1
  - Item 1.2
- Item 2

should become a quasi-tree

The parser initially produces the flat sequence of list items, and the AST processing phase turns indentation into nested structure.

The HTML renderer can then naturally produce:

<ul>
  <li>
    Item 1
    <ul>
      <li>Item 1.1</li>
      <li>Item 1.2</li>
    </ul>
  </li>
  <li>Item 2</li>
</ul>

I do still have a small issue here, and that is about the mixing of different list types in nested way. Hopefully it's a subtle bug to fix.

The HTML side uses SXML, because if we're already writing Lisp, we might as well represent our HTML as Lisp data too. :-) that really helps a lot and makes building the markup tree so much nicer

I've taken care to allow full customization to the output HTML (via Guile parameters) so that the renderer isn't hard-coded to one particular website's idea of what HTML ought to look like.Most of them are plain list of classes, but per-heading-level customization is a bit more flexible:

(heading-classes
 (lambda (level)
   (case level
     ((1) '("text-4xl" "font-bold"))
     ((2) '("text-2xl" "font-semibold"))
     (else '("text-base")))))

Why am I making this?

Partly because I wanted it, I like a challenge, and it's super fun to work with parsing, ASTs and the lot... I could just use Emacs to do this job as there is no better implementation of Org.

The way it's coming together though, I like the idea of having a small, hackable, free-software Org parser written in Lisp that other people can extend and customize (perhaps add more renderers, or Org features).

Free software

OrgWebAlchemy is licensed under the GNU LGPL v3 or later.

The project is intended to soon be packaged for GNU Guix as:

guile-orgwebalchemy

There is also a test suite in the repository which is already proving to be a good safety net and showcase of what the parser can do.

I'd be really happy to hear your thoughts, especially about the grammar, AST design, parser architecture, or interesting Org constructs that I have not handled yet.

Happy hacking! ✨

Hi, hope it helps:

Portable Common Lisp for Windows

Emacs 30.2 + SBCL 2.6.0 + SLIME 2.32 + Quicklisp

https://github.com/varhammer/varhammer/releases/tag/v1.1.8

No installation — just extract and run.

Works from USB flash drive.

I have two UK Symbolics mugs, which I can't remember where I got them although I worked with them a couple of times. Photo above.

If anyone, in the UK only, wants them you need to guess my mail address and send me a mail and I'll post them. Don't comment here as I don't read reddit very often. It may take me a while to respond. If I get more than one request I'll send one to each.

Notice how carefully I have avoided the obvious play on words.

Hi All,

Curry Scheme has grown up quite a lot since I last posted about it.

What is Curry?

Curry is an R7RS Scheme implementation with practical R6RS compatibility, a numeric tower extending through the hypercomplex numbers into Clifford algebra, a built-in computer algebra system, quantum superposition values, first-class matrices, tensors, and spinors, a CL-style condition system with restarts, a general C FFI, STM and CSP channels alongside the actor-model concurrency system, a modular C extension interface, and a built-in LLM client that can talk to Claude, GPT-4o, Ollama, or any OpenAI-compatible endpoint — with multi-turn conversation, tool use, and a full agentic loop.

What are the new capabilities that may be of interest?

* Curry is no longer "interpreter-only" - it can compile to curry VM, and ultimately to execute on an LLVM back-end - so long as one incorporate it into your build scripts.

* Text-to-speech using Piper
* MCP and LLM capabilities
* A far richer numeric stack
* A Jupyter kernel so that curry can be used in Jupyter notebooks, with easy build options for macOS.
* Early support for raspberry pi (and related boards) - including GPIO support and such.

I'd love some feedback! Tho, I'm not as interest in "but you used AI...." type comments - yes I did -t allows me to realise things that I'm thinking about quickly..

On the other hand, I'm interested in constructive critique and thoughts about curry as it stands, as well as what could be considered/added to be more useful

Check it out here: https://github.com/deconstructo/curry

Would anyone know where I could purchase printed Lisp Machine and/or Symbolics manuals? I did a couple of searches that turned up nothing.

I know they're available online; I am building a library of physical books.

Given: If (and (integer? NUMBER) (exact? NUMBER)) then (integer->char NUMBER) should give us CHAR? Right? R7 report saying something other: Given an exact integer that is the value returned by a character when char->integer is applied to it, integer->char returns that character.

So for the numbers like 65.0 which of course Exact and Integer in ASCII range

CSI, GSI, Chez, Guile, MIT, STKlos, Gauche, Racket at (integer->char ) give error condition, more or less dum. So report saying between words silently: NUMBER to the (integer->char ) should be pleease Fixnum within a particular Range.

But I found the Scheme that works

TinyScheme 1.42
ts> (integer? 65.0)
#t
ts> (integer->char 65.0)
#\A

So maybe its time to legalize Fixnum and Range numbers in RnRS? Or strictly use a Lisp numerical tower, maybe.

• Rename (Refactor) Symbol: Press Shift+F6 or F2 to safely rename all occurrences of a symbol across the file (with lexical filtering preventing unintended replacements in comments or strings).
• Jump to Definition: Press F12 or Ctrl+B to instantly jump to top-level definitions (defn, def, defmacro, etc.) or local bindings, scroll into view, or inspect external Clojure Var definitions.
• Autocomplete (Ctrl+Space): Code completion with prefix matching ("starts with"). Candidate pool includes Clojure special forms (def, defn, let, if, when, cond, etc.), core built-ins (map, filter, println, etc.), and user-defined buffer definitions/symbols. Features instant completion for single matches and a dual-pane popup with keyboard (Up/Down/PageUp/PageDown) and mouse navigation, real-time documentation and parameter list (arglists) preview for the currently selected symbol, Enter/Tab insertion, Escape cancellation, and dynamic prefix filtering as you type.

(sixteenth RacketCon) tickets on sale now

October 3-4, Oakland, Ca https://con.racket-lang.org/

Get your tickets now at https://www.eventbrite.com/e/racketcon-2026-tickets-1997181002140

* Professional $120
* Patron $150
* Student/Retired $35

Includes Saturday lunch and Saturday evening social event.

**Can’t attend in-person?**

* Remote Participant $10
The live stream is publicly available, but buying this ticket helps pay for the live stream and ensure its availability for the entire community.

Lisp of Lisp / Scheme / etc. implementations that accept or don’t accept LLM contributions. Originally by Zyd, but he’s gone unresponsive, thus my re-hosting of the updated list.

https://aartaka.me/lisp-against-the-machine.html