Tootfinder

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…

If you need every last drop of performance, you can remove the guard rails Go has. But you probably really really shouldn't because your time is more valuable than the hardware you save on making a great protobuf parser. #GophersUnite

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, …

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…

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 …

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.

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.

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ć,…

🥳 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.

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

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-…

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…

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

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…

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…

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

Correctness-Guaranteed Code Generation via Constrained Decoding
Lingxiao Li, Salar Rahili, Yiwei Zhao
https://arxiv.org/abs/2508.15866 https://arxiv.org/pd…

Correctness-Guaranteed Code Generation via Constrained Decoding
Language Models (LMs) are increasingly being used for code generation, but ensuring the correctness of generated programs remains a significant challenge. Although imperfect code may be acceptable during software development with human oversight, domains such as video games and robotics require one-shot correctness for runtime-critical components. We present a constrained decoding algorithm for generating semantically correct programs that incorporates a context-sensitive parser, which, at each…

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…

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
===============================================…