I am a big fan of Janet, which I find pretty cool to use and manipulate.

Two features come out as strikingly useful to me, on top of the language being compiled.

• The very simple to use and very efficient PEG in the standard library
• The DEAD EASY C interop, which makes using C features or libraries a dream.

I use this language at work to parse logs, automate some tasks, and I also use it on my personal blog and services for Gemini/text parsing (e.g. to HTML).

I am writing the wayland compositor I wish already existed in Zig. It is the only language I’ve found that I find beneficial to use for the task over C.

Downsides of Zig compared to C include an immature ecosystem and a not-yet-stable language. Benefits include a much more powerful type system, elimination of the need for a preprocessor, and nice modern language features that I miss in C like sum types, optional types instead of null pointers, and proper namespaces.

Even with all these niceties, I don’t feel like Zig is significantly more complex than C. This compositor is my first ever project in Zig and I learned the basics of the language in the first couple days/weeks working on it.

Repository here if you want to check it out. I’ve been daily driving it for about 6 months now, the only thing holding back an 0.1.0 release are some widely breaking changes I haven’t had time to finish yet.

I’ve got a structural text editor I’m working on in Fennel: https://git.sr.ht/~technomancy/anarres

Right now I have a UI in love2d and an ed-type line editor UI. I think my next step is to expand the love2d one to be less textual and use actual graphical elements to draw each element of the AST.

I’m writing a lot of Lua, which I love for packing so much power in such a small number of “features”, I find it very elegant and even relaxing to work with and it is usually “fast enough” for my uses. I’m writing what I describe as a “minimalist web systems framework” with it called tulip and building a website (kind of a niche search engine) with it in parallel.

I’ve settled on Nim as my language of choice for personal projects. (It was a shootout with Rust, but the latter had too many inexplicable error messages and IMHO is too wordy.)

• Literally compiles to C, so it’s fast and portable and bridges easily.
• Generally pleasant syntax. Overloading in functions and operators, plus universal fn call syntax, makes for nice APIs.
• Lets me do low level gunk without as much hassle as Rust, while keeping my high level code safe.
• Community is friendly and not too huge.

OCaml is arguably small (it’s definitely not easy to find a job for it), but I’ve been using it for web development, hardware development, and even to play around some graph algebra. I love ML in general, but I am particularly fond of OCaml for the above-average quality of the ecosystem (and PPX extensions!).

I’ve used two specialized languages for digital signal processing/audio programming:

• Faust: https://faust.grame.fr/
• Soul: https://soul.dev/

Faust is an older language developed in academia and supports a functional design and support for a huge variety of platforms from microcontrollers to the web browser via WebAudio + WebAssembly

Soul is a new language that just hit 1.0 a couple of weeks ago. It is a fresh take on the same problem space, but it has a simpler syntax and seems targeted at devs that are familiar with C++ or Java.

Both have real advantages for doing audio programming and have active communities with a lot of open source code available to build on top of.

Since both support compiling to WebAssembly, I’ve added a code editor to the experimental browser-based audio synthesis platform[1] I’m building to dynamically compile code in either one of these languages to WebAssembly on the fly and then load the compiled module into the WebAudio graph.

The fact that both languages are pretty simple with a tiny toolchain and specialized domain makes this dynamic compilation simple and effective. It’s a great way to prototype audio effects quickly without having to spin up a ton of boilerplate or project setup.

[1] https://github.com/ameobea/web-synth

Janet is my current “small” language. I’m actively trying to work to make the ecosystem in Janet better (I’m hardly alone there, the gitter is a nice place to hang out).

I tried out Janet for Advent of Code, fell in love with its PEG library (it’s the first time PEGs have made sense to me). Then, I really liked the fact that Janet has a REPL-based doc function, which is something I had wanted for PISC. Then, I found out that Janet makes building your scripts into an executable very easy (which, as a windows user, is something I like a lot, and does an end run around the difficulties of deploying Python or Erlang).

Since then, I’ve been enjoying the Janet gitter/matrix room a lot, and I’ve liked the language enough to want to help it work better on Windows. I’ve also been trying to write libraries for some of the edges I’ve found in it, and I’m using it to build a couple of side projects related to Personal Information Management. I really think @bakpakin got it 95% right.

In awk (and some Plan 9 rc), I’m writing a simple markup language that compiles to HTML: em.git

J is a small language. I want to write small programs from time to time, to simply flex my mind in a different direction

(Not my language; one I’m contributing some small things to:)

“Small” language because:

• no modifiers
• no exceptions
• no null pointers
• no implicit imports
• no static members
• no collection literals
• no implicit conversions
• no method overloading

More on not repeating existing mistakes:

• <> for generics is wrong and broken, therefore use []
• Type ident works poorly with generics, therefore use ident: Type
• fields + methods + properties failed, instead avoid leaking method/field implementation details to callers

Pretty much the only thing I plan to spend language on is merging if-statements, pattern matching and the ternary operator into unified condition syntax.

That let’s me get rid of three moderately complex features in favor of one that is only slightly more complex (but vastly less complex than the sum of the complexity of all three).

I’d like to work on Prolog for some stuff. For me, it’s a language that is very concise and I feel very confident about the code I make that it is correct even if I write fewer tests. It is not perfect, there are sometimes performance issues, lack of tooling, so for anything serious, I will probably not choose it. My last public work with Prolog is an HTTP Server for Scryer Prolog. It still needs more work but it is already there if you want to try it. Some months ago I also shipped an HTML5 game with some parts written in Tau Prolog.

I’m at the first step of using 6502 assembly to write a Gopher client for the Apple II. I would say that the main feature is performance ;)

Is Raku small? I’m asking because if I’m being pedantic, Raku is not Perl. I’m writing a text based RSS aggregator in Raku, but mainly for learning (I never learned Perl properly either).

I’ve been rewriting my static site generator in Posix shell and AWK. I don’t plan on getting hired for either of those skills anytime soon XD

I am currently porting my algotrading program from Python to Nim for three reasons.

• It’s faster that Python
• It’s compiles into a crossplatform, single executable binary — deployment is basically uploading a single tiny executable file. No “virtualenv” , containers or other uncessantly complications
• Nim still has the ergonomics of Python (which was why I used it in the first place. So I don’t feel like I am missing out on anything

I like writing small languages or VMs for the purpose of demonstration. Maybe to demonstrate how to write a bytecode compiler, or add inline caching, or do bytecode rewriting, …

Aside from that, not much. These days I tend to write my DSLs embedded in Python :(

I’m using OCaml for synsh.dev, which generates shell pipelines from examples of the input to the pipeline and expected output. I picked it primarily because it targets both native binaries and JavaScript, because it provides straightforward support for asynchronous execution (through Lwt), and because I have a lot of prior familiarity with it.

I had been using LDPL for a little while on toy projects, one such project was porting a simple BASIC game to LDPL https://github.com/photogabble/ldpl-space-mines

To answer your question, my biggest win for a creating an internal DSL in Python was to help QA and business analysts construct test cases for a financial rules engine.

When the rules engine was rewritten in Java, I was able to write a compiler in Java so we could port the existing tests to the new system. There was some Jython in the mix as a way to test the tests, but that was only done during the development of the port.

I find little languages have two really powerful uses

• Providing a minimal interface for a narrow use case to domain experts
• Achieving semantic clarity for things that would be hard to express in the host language

The second one is where you can have some larger multiplier in productivity by making opaque hard to reason about code seem playful. Logic, constraint, probabilistic and differentiable programming come to mind.

I have written and maintain a number of command line server admin/developer type tools (and wrote and maintain a library, to make it easier to write and distribute said tools) in posix shell.

Shell is obviously quite common in ops roles, but I don’t know many jobs are hiring specifically to write shell?

Coincidentally, just like @acdw, I recently wrote the most bare-bones of static site generators, in POSIX sh; it’s in this gitea repo. I’m using it now to render static pages for my tilde.team webspace.

It’s barely more than a wrapper around cmark (the CommonMark reference implementation) right now, but it was good practice with sh nonetheless. It also gave me an reason to learn some basic sed and awk. I’d never touched those before, and I think I understand what makes them useful better now.

I haven’t touched it for a while, but I hope to go back to it some time not so far in the future and touch it up. Maybe one day it’ll be a full static site generator! Will it still be written in sh? Who knows! (But perhaps for my own sanity I should change languages before I make it bigger…)