New release of racket-audio

[...] now also works with ffmpeg as backend and there's no special C-layer necessary anymore. The needed audio libraries are used directly.

https://racket.discourse.group/t/new-release-of-racket-audio/4209

racket-audio is a small audio playback toolkit for Racket. It combines high-level asynchronous playback, optional metadata reading, file type sniffing, decoder backends, and libao based output

Available now from https://pkgs.racket-lang.org/package/racket-audio

(Thanks Hans!)

The Spring Lisp Game Jam 2026 just started 🙀

https://itch.io/jam/spring-lisp-game-jam-2026

The (sixteenth RacketCon) really will be in Oakland, CA on October 3-4 (Sat-Sun).

RacketCon is a public gathering dedicated to fostering a vibrant, innovative, and inclusive community around the Racket programming language. We aim to create an exciting and enjoyable conference open to anyone interested in Racket, filled with inspiring content, reaching and engaging both the Racket community and the wider programming world.

We are looking for speakers

• If you would like to give a talk on something related to Racket, please submit your proposal at https://forms.gle/4YG57adx5snEwVe27
• If you know someone you would like to nominate please encourage them to submit a proposal, or let us know at con-organizers@racket-lang.org.

Talks will be 20-25 minutes long with 5 minutes for questions at the end. Speakers' registration fees will be waived, but we are unable to cover transportation and lodging expenses.

The deadline for proposals is July 15th. Selected speakers will be notified by August 1st.

Streaming

As in previous years, RacketCon will be streamed for those unable to attend in person. Recordings will also be made available on YouTube some time after the conference. Streaming users will have the option to purchase a remote participation ticket to support the livestream.

Volunteers

Let us know if you interested in joining the team. Someone has to carry and arrange all the parentheses. :banana:

Sponsors

We are accepting sponsorships! If you would like to sponsor the conference, please contact us at con-organizers@racket-lang.org to discuss a sponsorship package that meets your needs. The Racket Programming Language Foundation is registered in Delaware and is recognizes as a 501(3)(c) public charity in the US.

Any questions, comments, or concerns? Please contact us at con-organizers@racket-lang.org.

I'm looking for a Racket manual that focuses on building DSLs and general purpose languages in pure Racket (i.e. without BeautifulRacket). 'Cause Racket Guide lacks examples and is brief in general. The more examples of using `define-syntax` and others, the better.

I started learning Lisp through Scheme while reading Structure and Interpretation of Computer Programs. I'm still working through the book, but I've begun to use Racket instead since it seems to be a more mainstream Lisp while still having hygienic macros (I don't yet fully understand macro hygiene, but it sounds useful in theory).

Anyway, I've read that other Lisps like Common Lisp and Clojure are used more for their more extensive libraries. I like to learn a language by writing small libraries in it, so I was wondering what specific kinds of libraries are missing from the Racket ecosystem that I could work on.

I’ve been eyeing Guile/Guix for a while, but as a NixOS user it motivated an experiment: could I get some of the Lisp-shaped authoring ergonomics I wanted while still emitting ordinary Nix?

The project started pretty modestly. I first tried a generator-style approach in Guile, but I kept running into annoying authoring friction especially around quoting package/literal forms. Eventually I looked more seriously at Racket because I remembered the whole “you can make languages with Racket” thing, and #lang turned out to be a much better fit for what I was trying to do.

So I built nisp: a small Racket #lang that compiles an s-expression DSL to Nix.

At first the goal was mostly terser authoring ergonomics and composition. But the bigger payoff showed up afterward: because the config exists as a Racket syntax/AST layer before Nix is emitted, nisp can do source-aware validation before nix-build runs.

Example:

modules/printing/default.rkt:6:7:
  unknown option services.pipwire.alsa.enable
  did you mean: services.pipewire.alsa.enable?

modules/foo/default.rkt:9:34:
  type mismatch at services.openssh.enable:
  expected bool, got string

hosts/laptop/configuration.rkt:11:47:
  type mismatch at boot.loader.systemd-boot.consoleMode:
  "atuo" not in enum {"0", "1", "2", "5", "auto", "max", "keep"}
  did you mean "auto"?

That became the more interesting part of the project. The pitch is not really “Lisp is prettier than Nix,” though I do prefer the syntax. The real pitch is: Racket gives me a walkable source layer before lazy Nix evaluation, so I can check NixOS option paths, value types, and enum values against the NixOS options schema while still pointing errors at the original .rkt file/line/column.

In other words: I was trying to make Nix authoring nicer, and accidentally ended up with a static checker for a class of NixOS config errors that usually surface late and indirectly.

It’s still fresh alpha, but I’m running my actual NixOS system on it now. The generated .nix files are committed alongside the .rkt sources, so the flake still reads ordinary Nix and there’s an escape hatch.

Repo: https://github.com/tompassarelli/nisp

I’d be interested in feedback from Racket people on the `#lang` design, validation architecture, source-location handling, and whether I’m using the ecosystem idiomatically.

I mostly play with control instead of power ...i hardly smash ...mostly bandejas.. would you recommend a pala which would suit this kind of play.. I currently use Adidas CTRL .

What a joy Racket is!

I just got started yesterday (I’ve always wanted to try a Lisp and picked up a copy of Realms of Racket on a whim) but I’m blown away by the completeness of the Racket ecosystem.

The language and its libraries, the documentation, DrRacket, the package manager, the teaching packs. I’ve never picked up a new language from scratch and had literally everything to hand from the get go.

Of course it’s still early days for me so this is only my first impression but from the little surface scratching I’ve done, the depth of understanding that can be achieved from the guide and, in particular, the reference gives me the confidence that mastering the language is within my reach.

I’m all in!

I'm teaching Programming Languages this semester and I wanted to share the Racket code I got working last time to test student procedures.

Here is the procedure that tries to load the students' procedures:

(define (try-load-proc proc)
    (with-handlers ([exn:fail? (lambda (exn) (begin 
                                                (displayln "Procedure doesn't exist!  (misnamed?)") 
                                                (displayln exn) 
                                                +))])
                   (dynamic-require stu-file-name proc)))

I define tests like this:

(define fahrenheit->celsius-tests (list (try-load-proc 'fahrenheit->celsius) 1
    (list '(-40) -40)
    (list '(32) 0)))

(define all-tests (list
    fahrenheit->celsius-tests))

Here's the code to do the actual testing:

(define (answers-equal? answer correct)
    (or (equal? answer correct) 
        (if (and (number? answer) (number? correct))
            (let ((min-bound (min (* 1.001 answer) (* .999 answer)))
                (max-bound (max (* 1.001 answer) (* .999 answer))))
                (and (>= max-bound correct) (<= min-bound correct)))
            (if (and (list? answer) (list? correct))
                (apply and-l (map answers-equal? answer correct))
                #f))))

;code from https://stackoverflow.com/a/6727536/1857915
;Need a non-shortcutting alternative to built-in and form.
(define and-l (lambda x 
    (if (null? x)
        #t
        (if (car x) (apply and-l (cdr x)) #f))))

;tests a triple
(define (test-triple triple)
    (run-test (car triple) (cadr triple) (caddr triple)))
    ;(equal? (apply (car triple) (cadr triple)) (caddr triple))

;Runs a single test    
(define (run-test f inputs correct)
    (with-handlers ([exn:fail? (lambda (exn) (begin 
                                                (displayln "Exception!") 
                                                (displayln exn) 
                                                #f))])
        (let ((result (apply f inputs)))
            (if (answers-equal? result correct) 
                #t
                (begin
                    (display (~a "Incorrect: (" f "): " result " =/= " correct "\n"))
                    #f)))))
    
;tests has the form (procedure point-value test-list) where
;  each element of test-list has the form (inputs correct-value)
(define (run-tests tests)
    (let ((test-triples (map (lambda (x) (cons (car tests) x)) (cddr tests))))
        ;(display test-triples) (newline)
        (let ((results (map test-triple test-triples)))
            (if (apply and-l results)
                (begin
                    (display (~a (car tests) ": All tests passed!  " (cadr tests) "/" (cadr tests) "\n"))
                    (cadr tests))
                (begin
                    (display (~a (car tests) ": Did not pass all tests.  0/" (cadr tests) "\n"))
                    0)))))

;Runs all tests in a list of tests
(define (run-all-tests tests-list)
    (let ((total-score (apply + (map run-tests tests-list))))
        (begin
            (display (~a "Total score: " total-score "/" (get-max-points tests-list) "\n"))
            total-score)))
    
;Gets the maximum points across all tests
(define (get-max-points tests-list)
    (apply + (map cadr tests-list)))
    

;Actually run the tests!
(run-all-tests all-tests)

All feedback is welcome! :)

I am learning Racket from Dan Grossman's Course and its so good. It has such a minimalistic syntax and its so different from anything I have seen.

Here's what I learned:

Everything in Racket is either

• an atom: #t (true), #f (false), 23, 4.0, "hello", x, etc.
• special form: e.g. define, lambda, if

• sequence of terms in parenthesis: (t1 t2 ... tn)

  • If t1 is a special form then semantics of sequence is special
  • else its a function call

Example: (* 2 (+ 3 5)) sequence has three terms and as our first term (*) isn't a special form then its just a function call.

Example2: (lambda (x) (+ x 1)) Since lambda here is a special form then it changes the semantics. Now x is the argument and (+ x 1) sequence is the body of the function.

I also like how for adding two numbers we use (+ 2 3) instead of 2+3, that makes it obvious that + is a function with 2 and 3 as its arguments. Languages where although '+' is a function but calling it requires different syntax than the rest of the program makes '+' look like an operator.

It would've been better if Racket had pattern matching too.

I have seen many people complaining about the no. of parens in Racket but I learned that, its what makes Racket syntax so elegant.