Tootfinder

More on the crisis in open-source maintenance as exemplified by libxml2: https://lwn.net/SubscriberLink/1025971/73f269ad3695186d/
Some money *has* to start flowing into this community or the foundations we all rely on will start rotting away. Given the many-bi…

from my link log —
Rewriting the Ruby parser.
https://railsatscale.com/2023-06-12-rewriting-the-ruby-parser/
saved 2024-12-26

Rewriting the Ruby parser
At Shopify, we have spent the last year writing a new Ruby parser, which we’ve called YARP (Yet Another Ruby Parser). As of the date of this post, YARP can parse a semantically equivalent syntax tree to Ruby 3.3 on every Ruby file in Shopify’s main codebase, GitHub’s main codebase, CRuby, and the 100 most popular gems downloaded from rubygems.org. We recently got approval to merge this work into CRuby, and are very excited to share our work with the community. This post will take you thro…

from my link log —
Optimizing a simple expression parser in Rust.
https://rpallas92.github.io/math-parser/
saved 2025-07-10 https://

Syntactic Completions with Material Obligations
David Moon, Andrew Blinn, Thomas J. Porter, Cyrus Omar
https://arxiv.org/abs/2508.16848 https://arxiv.org/p…

Syntactic Completions with Material Obligations
Code editors provide essential services that help developers understand, navigate, and modify programs. However, these services often fail in the presence of syntax errors. Existing syntax error recovery techniques, like panic mode and multi-option repairs, are either too coarse, e.g. in deleting large swathes of code, or lead to a proliferation of possible completions. This paper introduces $\texttt{tylr}$, a parser and editor generator that completes arbitrarily malformed code by inserting ob…

🥳 New Kitten Release
• Improved Markdown parser
Kitten’s JavaScript tagged template strings (`kitten.html`) no longer fail to render as expected when interpolated values are used inside of Markdown where the Markdown render changes source order.
So, for example, the following will now work correctly, whereas, previously, the link source and link text would have been erroneously flipped:
kitten.html`
<markdown>
[${linkText}](${linkSource})
…

app/CHANGELOG.md at main
app - A web development kit that’s small, purrs, and loves you.

Wooo, added another feature to the dice parser: the ability to count dice. I'm really happy that I implemented this with a parser, but I'm definitely gonna need to clean up the code here in a bit.
https://dice.jamesthebard.net/usage/#dice-counts

Inferring Attributed Grammars from Parser Implementations
Andreas Pointner, Josef Pichler, Herbert Pr\"ahofer
https://arxiv.org/abs/2507.13117 https:/…

Inferring Attributed Grammars from Parser Implementations
Software systems that process structured inputs often lack complete and up-to-date specifications, which specify the input syntax and the semantics of input processing. While grammar mining techniques have focused on recovering syntactic structures, the semantics of input processing remains largely unexplored. In this work, we introduce a novel approach for inferring attributed grammars from parser implementations. Given an input grammar, our technique dynamically analyzes the implementation of…

So, @… is working on using LLMs to process XML Except for, the models can’t write legal XML. So he’s using the model to generate a sloppy-XML parser: https://lucumr.pocoo.org/202…

My First Open Source AI Generated Library
In a first for me, I published some agentic programmed AI slop to PyPI.

I've sent out a funding application to OSFF for Intel ME tooling.
🥳
I had started an Intel ME file system parser for recent and current versions:
https://github.com/fiedka/me_fs_rs 👈🧐
Then I realized how much overlap there is between this, MEAnalyzer, the long unmaintained me_clean…

GitHub - fiedka/me_fs_rs: Intel ME filesystem parser written in Rust :crab:
Intel ME filesystem parser written in Rust :crab:. Contribute to fiedka/me_fs_rs development by creating an account on GitHub.

Okay, _now_ I'm done. Fixed a few parser errors and implemented a skew option (the `^` value) that will push the average value towards either 1 or the maximum of the dice. I like that once you get the parser up and running that it's easy to add stuff to it. I now am the official owner of a completely overkill dice running program.
For the example below, the skew is `2.0`. The random value is raised to the `1/skew` power before being multiplied by the number of sides of the …

Koniec końców udało się jedynie napisać działający parser klatek z tej "szitman supercamery" ale wypluwa tylko jpegowe klatki na stdout, które przejmuje przez gstreamer i dalej wyświetlam/tworze sink z pipewire w usernamespace/cokolwiek.
Poległem na razie przy implementacji gstreamer sinka w samym Rust, a v4l2loopback... DKMS wykrzaczył się po upgradzie kernela do 6.16 z ostatnim pacman -Syyu - fix już jest w repo, ale pakiet jest niezaktualizowany w . Mógłbym sam kompilować,…

Today i wrote a parser & import to convert some semi-structured plain text into 40 different newsletter issues for an upcoming newsletter relaunch. And also fixed the internal structure of some of the mail widgets we are using, and their HTML representation.

The new integrated Markdown parser I’ve been implementing in Kitten has been kicking my ass for the past few weeks but I think I finally have it fully working and seamlessly so. Expect a new release this/next week that brings the parsing of Markdown pages (.page.md files) in your apps up to the standard of the recently-improved runtime Markdown parsing in Kitten HTML tagged-template strings (within `<markdown>…</markdown>` blocks).
The coolest thing is I was able to impleme…

Time to write a dice roller...gonna use `lark` to parse the string so I can just type out the roll and add tags for the damage types and let it do the math. Is it overkill? Yes. Does it work? No, not yet...but that's the fun part.
#python #lark

es ist ja mit Blick auf Datenanalyse schon einigermaßen tragisch, dass die VDs die Seitenzahlen zwar penibelst aufschlüsseln, man aber einen komplexen Parser braucht, der das dann auch irgendeine Art von normierter Zahl herunterbricht, mit der man dann auch rechnen kann:
"1 ungezähltes Blatt Bildtafel, 1 ungezähltes Blatt, 28 ungezählte Seiten, 3028 Spalten, 1055 Spalten, 1 gefaltetes Blatt"
"[27] Bl., 1836 Sp., [1] Bl., 1204 Sp., [52, 4] Bl., Sp. 1-60, S. 61-115, Sp…

Work continues on the Dice Parser. Added a ton of features:
- Raw rolls
- Dice rerolls
- Keeping the nth lowest/highest dice
You can literally now do some craziness like "roll 10d10, reroll all rolls 3 or less, keep the two highest as fire damage, then roll 3d4, keep the lowest two values, keep those as piercing damage"
```python
dice.roll("10d10 reroll 3 keep 2[fire] 3d4 keep -2[piercing]")
dice.roll("10d10!3k2[fire] 3d4k-2[pi…

from my link log —
Nearley.js: a toolkit for parsers written in JavaScript.
https://nearley.js.org/
saved 2025-06-22 https://dotat.at/:/TV…

Incremental Language Understanding for Online Motion Planning of Robot Manipulators
Mitchell Abrams, Thies Oelerich, Christian Hartl-Nesic, Andreas Kugi, Matthias Scheutz
https://arxiv.org/abs/2508.06095

Incremental Language Understanding for Online Motion Planning of Robot Manipulators
Human-robot interaction requires robots to process language incrementally, adapting their actions in real-time based on evolving speech input. Existing approaches to language-guided robot motion planning typically assume fully specified instructions, resulting in inefficient stop-and-replan behavior when corrections or clarifications occur. In this paper, we introduce a novel reasoning-based incremental parser which integrates an online motion planning algorithm within the cognitive architectur…

Got the documentation for the dice parser software online and now I can close the laptop and relax a bit. I think it still needs some cleaning up, but it's good enough for now.
#python

from my link log —
IELR(1): practical LR(1) parser tables for non-LR(1) grammars with conflict resolution.
https://people.computing.clemson.edu/~malloy/publications/papers/sac08/paper.pdf
saved 2025-06-05

Advanced LPeg techniques: A dual case study approach
Zixuan Zhu
https://arxiv.org/abs/2507.01272 https://arxiv.org/pdf/2507.01272

Advanced LPeg techniques: A dual case study approach
This paper presents advanced optimization techniques for Lua Parsing Expression Grammars (LPeg) through two complementary case studies: a high-performance JSON parser and a sophisticated Glob-to-LPeg pattern converter. We demonstrate how strategic grammar construction can dramatically improve parsing performance without modifying the underlying LPeg library. For the JSON parser, we implement substitution capture and table construction optimization to reduce memory allocation overhead and improv…

from my link log —
comrak: a CommonMark and GFM compatible Markdown parser and renderer in Rust.
https://github.com/kivikakk/comrak
saved 2025-03-31 …

GitHub - kivikakk/comrak: CommonMark + GFM compatible Markdown parser and renderer
CommonMark + GFM compatible Markdown parser and renderer - kivikakk/comrak

PathDB: A system for evaluating regular path queries
Roberto Garc\'ia, Renzo Angles, Vicente Rojas, Sebasti\'an Ferrada
https://arxiv.org/abs/2507.01755

PathDB: A system for evaluating regular path queries
PathDB is a Java-based graph database designed for in-memory data loading and querying. By utilizing Regular Path Queries (RPQ) and a closed path algebra, PathDB processes paths through its three main components: the parser, the logical plan, and the physical plan. This modular design allows for targeted optimizations and modifications without impacting overall functionality. Benchmark experiments illustrate PathDB's execution times and flexibility in handling dynamic and complex path queries, …

Okay, added a few more features and I'm really liking the results. I added the `-` operator for `dice_groups` which was a bit more tricky than I thought it'd be. I also added the ability to roll a dice group multiple times via a `x`|`*` operator. I removed the requirement that a dice group has to have a damage type associated with it since the only way you can roll something like `1d4-1` is in a dice group since there is a minimum value of 1 associated with it.
The code liv…

Compiling a Q# Subset to QASM 3.0 in TypeScript via a JSON Based IR
Marcus Edwards
https://arxiv.org/abs/2506.23407 https://arxiv.org…

Compiling a Q# Subset to QASM 3.0 in TypeScript via a JSON Based IR
We implement a compile toolchain from Q# to QASM 3.0 including a full-featured lexer and parser implementation, as well as a compiler that supports a subset of Q# features. The lexer, parser and compiler are shown to work with various input Q# programs and the implementation is compared against existing Q# compile tools. Unlike the Microsoft implementation of the official Q# compile toolchain, our implementation is written in TypeScript in order to port functionality to web environments.

GhostShell: Streaming LLM Function Calls for Concurrent Embodied Programming
Jian Gong, Youwei Huang, Bo Yuan, Ming Zhu, Juncheng Zhan, Jinke Wang, Hang Shu, Mingyue Xiong, Yanjun Ye, Yufan Zu, Yang Zhou, Yihan Ding, Xuannian Chen, Xingyu Lu, Runjie Ban, Bingchao Huang, Fusen Liu
https://arxiv.org/abs/2508.05298

GhostShell: Streaming LLM Function Calls for Concurrent Embodied Programming
We present GhostShell, a novel approach that leverages Large Language Models (LLMs) to enable streaming and concurrent behavioral programming for embodied systems. In contrast to conventional methods that rely on pre-scheduled action sequences or behavior trees, GhostShell drives embodied systems to act on-the-fly by issuing function calls incrementally as tokens are streamed from the LLM. GhostShell features a streaming XML function token parser, a dynamic function interface mapper, and a mult…

So, I think I'm done for the evening. Managed to get the dice roller working as intended with the `lark` parser which is a Christmas miracle. I'll clean it up tomorrow and make it look a bit better code-wise, but I'm pretty happy it does what it says it does. I'll probably roll this into the Pathfinder 2E TUI character sheet.
```
$ python main.py
Roll to parse: (3d8 2d6 15)[lightning] (4d10)[piercing] 3d8
===============================================…

Invertible Syntax without the Tuples (Functional Pearl)
Mathieu Boespflug, Arnaud Spiwack
https://arxiv.org/abs/2508.09856 https://arxiv.org/pdf/2508.09856…

Invertible Syntax without the Tuples (Functional Pearl)
In the seminal paper Functional unparsing, Olivier Danvy used continuation passing to reanalyse printf-like format strings as combinators. In the intervening decades, the conversation shifted towards a concurrent line of work -- applicative, monadic or arrow-based combinator libraries -- in an effort to find combinators for invertible syntax descriptions that simultaneously determine a parser as well as a printer, and with more expressive power, able to handle inductive structures such as lists…

from my link log —
LALRPOP: a parser generator for Rust.
https://smallcultfollowing.com/babysteps/blog/2015/09/14/lalrpop/
saved 2025-03-31

A #Python package that can't be installed on Python 3.14, because the author had to implement a 200 line custom AST parser in `setup.py`? Yeah, why not.
#Gentoo #packaging #setuptools

from my link log —
The IELR(1) algorithm for generating minimal LR(1) parser tables for non-LR(1) grammars with conflict resolution.
https://people.computing.clemson.edu/~malloy/publications/papers/scp09/scp09.pdf
saved 2025-…