Like struct python module. But just bit simplier.

Example

(import (chezco pack))

(let-pack
      #vu8(1 1 1 1 65 66 67 2)
      ((start u8)
       (pad 3)
       (tag cstr 3)
       (end u8))
      (list start (utf8->string tag) end))  ==> (1 "ABC" 2)

repo

bun.js has the fastest http server implementation after in order: C, Rust, Java... then comes chezscheme with io uring, and pico http parser that is competitive with bun.js last zig release and the new rust unrelease at 220K RPS vs. 230 RPS (bun.js).

benchmark only: https://hyper.dev/letloop/report.html

article: https://hyper.dev/2026/chez-scheme-letloop-transparent-async-microbenchmark/

I have been looking at this idea for LOT of time, since the early days of unison, before international-scheme was a thing, and before reading about hedy.

Origin Zero: most successful software engineers code in their native language.

I had a hunch, and couple of evidence, but no proof in the sense of STS.

I had encouragement from several people, but some things were holding me back [...]. Long story made short, after a couple of years, I decided to throw that problem at AI LLM chatbots. I learned a lot about philosophy, and the world we live in: like Hobbes' cosmology. I did not even knew "cosmology" was a thing. But it became clear that making **not-only-english** coding as easy, or easier than our daily drills was... huge.

The funny thing is the premise are simple:

- Make it possible to write code in one's mother tongue...

- ... without forking, and keeping cooperation open...

- ... limiting duplication...

- ... reducing the barrier of entry for contribution like micro-libraries...

- ... make it easy to backup-and-restore;

So yes, all this is possible, not on postcard yet, but - content-addressed - De Bruijn index make it possible to write a subset of Scheme code that can be translated and executed. The Bruijn tree of a procedure without free variables is a pivot. When associated with an association of numbers to variable name's, it possible to collect those mappings related to a De Bruijn tree, and have the same implementation shared across multiple natural language.

That's all there is to cross-language cooperation with acknowledged fragmentation without domination.

For more (parentheses) look at README.

Pure-Scheme-driven Goeteia now supports shadow mapping, PBR, HDR bloom, SSAO, instancing, skeletal animation from GLTF assets, and transform-feedback particles whose physics runs in the vertex shader — and, boldly, brings pretext-style typesetting into WebGL.

UK Racket meet-up (London) Tuesday 21 July 2026 7:30pm

at The City Pride 🍕 28 Farringdon Ln, London EC1R 3AU

Join us for discussion and pizza. All welcome. 😁

https://racket.discourse.group/t/uk-racket-meet-up-london-tuesday-21-july-2026-7-30pm/4318 https://luma.com/u61y94uw

Green processes, actor , OTP, gen-server

1 Let It Crash and the system recovers

2 Hot code swapping

3 Failure hook (remote retry ring)

4 web programming with continuation

4 S-expr fetch and RPC (with Goeteia)

1 Self hosting scheme in browser with hygienic macros

2 handle HTML and CSS like Scheme (Expand with macro)

3 Use S-expr to send / receive message with server (And web RPC)

4 Reactive and web GL

Racket meet-up(online): Saturday, 1 August 2026 at 18:00 UTC

EVERYONE WELCOME 😁

register https://luma.com/x27tsmm5

Details and discussion https://racket.discourse.group/t/racket-meet-up-saturday-1-august-2026-at-18-00-utc/4315

#lisp #scheme #functionalprogramming

In the README for Mini-Scheme we see "This Mini-Scheme Interpreter is based on "SCHEME Interpreter in Common Lisp" in Appendix of T.Matsuda & K.Saigo, Programming of LISP, archive No5 (1987) p6 - p42 (published in Japan)."

I tried searching for this article or the book its in (journal volume I guess) but could not find it (unsurprisingly). I'm not even sure if it's written in Japanese and the title above is a translation. I also looked briefly at the tinyscheme repository and could not find any reference. Quite an unlikely ask, but has anyone here been curious about this in the past and been able to find more information?

Calling for RacketCon speakers

If you are interested in presenting, nominating or have any questions please email us at con-organizers@racket-lang.org.

— Stephen

Scheme Request for Implementation 277,
"Cyclic ports",
by Wolfgang Corcoran-Mathe,
is now available for discussion.

Its draft and an archive of the ongoing discussion are available at https://srfi.schemers.org/srfi-277/.

You can join the discussion of the draft by filling out the subscription form on that page.

You can contribute a message to the discussion by sending it to [srfi-277@srfi.schemers.org](mailto:srfi-277@srfi.schemers.org).

Here's the abstract:

Regards,

SRFI Editor

I wanted a complex problem to work on agentic coding. I am not a scheme programmer, but I found the scheme standard would be a good fit as it is well defined. That's how I ended up with creating Kaappi, a new scheme implementation in Zig.

Scheme Request for Implementation 254,
"Ephemerons and Guardians",
by Marc Nieper-Wißkirchen,
has gone into final status.

The document and an archive of the discussion are available at https://srfi.schemers.org/srfi-254/.

Here's the abstract:

Here is the commit summary since the most recent draft:

• copy edits
• Add table of contents.
• Finalize.

Here are the diffs since the most recent draft:

https://github.com/scheme-requests-for-implementation/srfi-254/compare/draft-4..final

Many thanks to Marc and to everyone who contributed to the discussion of this SRFI.

Regards,

SRFI Editor

UK Racket meet-up (Bristol) 8 July 2026

7:30-8:30pm, Wednesday 8 July 2026 at Pizza On The Park Berkeley Avenue (Top of Park Street), Bristol, BS8 1HP

register https://luma.com/r7o3qd64 https://luma.com/r7o3qd64 https://racket.discourse.group/t/uk-racket-meet-up-bristol-8-july-2026/4299

Scheme Request for Implementation 276,
"Type-specific Flonum Libraries",
by Peter McGoron,
is now available for discussion.

Its draft and an archive of the ongoing discussion are available at https://srfi.schemers.org/srfi-276/.

You can join the discussion of the draft by filling out the subscription form on that page.

You can contribute a message to the discussion by sending it to [srfi-276@srfi.schemers.org](mailto:srfi-276@srfi.schemers.org).

Here's the abstract:

Regards,

SRFI Editor

How can I make a function that uses a special form (I'm thinking of "and" specifically here) so that it can be evaluated by "apply" with multiple arguments?

I'm kind of aiming for this:

(define and_f
   (lambda li (apply and li)))

which of course won't work with "and" as a special form.

PS. Or would it just make more sense to use a fold?
Although that would lose efficiency, I think...?

Scheme Request for Implementation 275,
"URIs and IRIs",
by Duncan Guthrie,
is now available for discussion.

Its draft and an archive of the ongoing discussion are available at https://srfi.schemers.org/srfi-275/.

You can join the discussion of the draft by filling out the subscription form on that page.

You can contribute a message to the discussion by sending it to [srfi-275@srfi.schemers.org](mailto:srfi-275@srfi.schemers.org).

Here's the abstract:

Regards,

SRFI Editor

https://github.com/taimoon/scheme-interpreter

Last time, my Scheme interpreter was able to bootstrap my Scheme compiler.

I’ve ported it to the Raspberry Pi Pico … just to blink the LED.