PEpeter_d_sherman·Nov 11, 2025Submission
2 points · Open discussionantlr
grammars-v4
ANTLR2017–2025
antlr / grammars-v4
grammars-v4
Grammars written for ANTLR v4; expectation that the grammars are free of actions.
22Distinct people
23Mentions
0Explicit recommenders
11.1KGitHub stars
What to know before exploring
What it is
Grammars written for ANTLR v4; expectation that the grammars are free of actions.
GitHub
Where it is used
No documented product use was verified in the last source check.
What people are saying
No recommendation phrase was found in the indexed comments.
No classified warning is attached to this page. Read the discussions before treating silence as approval.
Also in these discussions
- antlr/antlr4 · linked in 2 of the same discussions
Mentioned in the same Hacker News threads. That is not proof they are substitutes.
This week on Hacker News
Nov 7–Nov 14 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/14/2026, 3:56:07 PM UTC.
No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.
Mentions over time
HN mentions by year23 dated mentions
Observed mentions: 2017-04-24 21:55:08 UTC to 2025-11-11 02:24:29 UTC.
Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.
View mention counts and date ranges
| Period | Start (UTC) | End (exclusive, UTC) | Mentions | Submissions | Comments |
|---|---|---|---|---|---|
| 2017 | 2017-01-01 00:00:00 UTC | 2018-01-01 00:00:00 UTC | 2 | 0 | 2 |
| 2018 | 2018-01-01 00:00:00 UTC | 2019-01-01 00:00:00 UTC | 2 | 0 | 2 |
| 2019 | 2019-01-01 00:00:00 UTC | 2020-01-01 00:00:00 UTC | 3 | 0 | 3 |
| 2020 | 2020-01-01 00:00:00 UTC | 2021-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2021 | 2021-01-01 00:00:00 UTC | 2022-01-01 00:00:00 UTC | 1 | 0 | 1 |
| 2022 | 2022-01-01 00:00:00 UTC | 2023-01-01 00:00:00 UTC | 4 | 0 | 4 |
| 2023 | 2023-01-01 00:00:00 UTC | 2024-01-01 00:00:00 UTC | 4 | 0 | 4 |
| 2024 | 2024-01-01 00:00:00 UTC | 2025-01-01 00:00:00 UTC | 2 | 0 | 2 |
| 2025 | 2025-01-01 00:00:00 UTC | 2026-01-01 00:00:00 UTC | 4 | 1 | 3 |
What Hacker News says
23 sourcesYep! Datalog syntax for Z3 is pretty neat! We used SMT [1] in our grammars paper because it allowed the most interoperability with solvers, but our technique also works with PROLOG; as tested our at the behest of reviewers at NeurIPS. I would assume that this should also work with datalog [2].
[1] https://arxiv.org/abs/2505.20047
[2] https://github.com/antlr/grammars-v4/blob/master/datalog/dat...
In ProofOfThought: LLM-based reasoning using Z3 theorem provingI found some benchmarks in the ANTLR project: https://github.com/antlr/grammars-v4/blob/master/java/java/B...
Project Parsing/Lexing Ratio
----------------------------------------
jdk8 5.34x
Spring Framework 3.81x
Elasticsearch 5.76x
RxJava 5.69x
JUnit4 4.51x
Guava 5.37x
Log4j 2.92x
Obviously this is just one toolkit, one language, and one set of examples. But in these benchmarks, the tokenization (lexing) time is a small fraction of the total parse time.
In Ohm: A user-friendly parsing toolkit for JavaScript and TypeScriptIf the tree-sitter runtime requirements are prohibitive and a pure JVM solution (IOW, no JNI) mandatory, then I'd recommend using antlr[0] with its representative grammar[1] as a starting point. See here[2] for more details.
0 - https://www.antlr.org/
1 - https://github.com/antlr/grammars-v4/blob/master/javascript/...
2 - https://github.com/antlr/grammars-v4/wiki
In Swc4j: SWC for JavaPerhaps this ANTLR v4 sqlite grammar? [1]
--
1: https://github.com/antlr/grammars-v4/tree/master/sql/sqlite
In Why I love Rust for tokenising and parsinghttps://en.wikipedia.org/wiki/HyperCard :
> It is among the first successful hypermedia systems predating the World Wide Web.
But HyperCard was not ported to OSX, now MacOS; which has Slides and TextEdit for HTML without MacPorts, or Brew,.
HTML is Hypertext because it has <a name= href=> edges and scripting IIUC.
Then there was Flash by Macromedia, which also created Dreamweaver for HTML editing before Adobe acquired Macromedia.
By now there are Open Web Standards like HTML5 and ECMAscript (ES (JS not JavaScript)), WebSockets, WebRTC, WebGL, WebGPU, WASM, and various UI-to-state bindings, as Flash called what e.g. React is used for today.
Instead of the DOM and JS addEventHandler, with React/preact you call setState(attr, val) to mutate the application state dict/object so that Components can register to be updated when keys in the state
Read the rest
dict are changed with useState() https://react.dev/learn/adding-interactivity#responding-to-e...
The HyperTalk language has a fairly simple grammar compared to creating a static SPA (Single Page Application) with all of JS and e.g React and a router to support the browser back button and deeplink bookmarks with URI fragments that "don't break the web":
https://github.com/antlr/grammars-v4/blob/master/hypertalk/H...
TodoMVC or HyperTalk? False dilemma.
Although not "official" by MS, perhaps the one from ANTLR's collection [0] is a good start (there are also other ANTLR VB6 grammars documented elsewhere). It does require knowing ANTLR's meta syntax, but it's not that far from (E)BNF.
[0] https://github.com/antlr/grammars-v4/tree/master/vb6
In Visual Basic for Applications Language Specification [pdf]Where is the SQLite test suite, please? I'd be very interested.
There are already SQL grammars, check https://github.com/antlr/grammars-v4 specifically in here I think https://github.com/antlr/grammars-v4/tree/master/sql I contributed to one of them, and I wrote my own for some personal work. Be warned, it's very involved, very complex and MSSQL is rather ill-defined.
Names bracket identifiers) in SQL are bloody awful. Sometimes square brackets are even compulsory, and why you can usually replace [...] with the SQL standard "..." , not always! Trust me, it gets worse.
I don't find antlr grammars to be brittle, and while they can lose in performance (by how much I don't know, perhaps quite considerably) they are very easy to maintain and I am very fortunate to have antlr to work with.
Edit: unless you are very familiar with the SQL and als
Read the rest
o a masochist, please don't try and write your own grammar. For someone with my background it was very time-consuming, without that background it will be a nightmare. Friendly warning.
This grammar "library" was cited as an example of what the format could look like:.
https://github.com/antlr/grammars-v4
There is everything from assembly and C++ to glsl and scripting languages, arithmetic, games, and other weird formats like freedesktop shortcuts, llvm ir or verilog.
In Llama: Add grammar-based sampling> Which brings me to the other approach: steering the LLM's output __as it is generating tokens__
A relevant PR:
https://github.com/ggerganov/llama.cpp/pull/1773
The plan is to support arbitrary grammar files to constrain token generation, similar to the grammar files here:
https://github.com/antlr/grammars-v4
In Show HN: Structured output from LLMs without reprompting> ...than it would be to learn the exact syntax and quirks and possibly bugs of someone else's implementation...
Yup. Also, having deep knowledge of the language is required.
SQLite's grammar is neat, modest. Creating a compatible parser would make a fun project. Here's a pretty good example: https://github.com/bkiers/sqlite-parser (Actual ANTLR 4 grammar: https://github.com/bkiers/sqlite-parser/blob/master/src/main... )
Postgres, which tries to be compliant with the latest standards, however...
SQL-2016 is a beast. Not to mention all the dialects.
I'm updating my personal (soon to be FOSS) SQL DML grammar from ANTLR 3 LL(k) to ANTLR 4 ALL(Star).
I've long had a working knowledge of SQL-92, with some SQL-1999 (eg common table expressions).
But all the new structures and extensions are a bit overwhelming.
Fortunately, ANTLR project has ~do
Read the rest
zen FOSS grammars to learn from. https://github.com/antlr/grammars-v4/tree/master/sql
They mostly mechanically translate BNFs to LL(k) with some ALL(Star). Meaning few take advantage of left-recursion. https://github.com/antlr/antlr4/blob/master/doc/left-recursi...
Honestly, I struggled to understand these grammars. Plus, not being conversant with the SQL-2016 was a huge impediment. Just finding a succinct corbis of test cases was a huge hurdle for me.
Fortunately, the H2 Database project is a great resource. https://github.com/h2database/h2database/tree/master/h2/src/...
Now for the exciting conclusion...
My ANTLR grammar which passes all of H2's tests diverges significantly from the official or product specific BNFs. Mostly wrt recursion.
Further, I found discrepancies between misc product's BNFs and their implementations.
So a lot of trial & error is required for a "real world" parser. Which would explain why the professional SQL parsing tools ask for money.
I still think creating a parser for SQLite is a great project. Hand-made or using grammar toolkit of choice. (I hope to play around with Pratt and PEG parsers some day.)
FWIW, here's a repo of ANTLR grammars: https://github.com/antlr/grammars-v4
Many of them are incomplete, but it gives a good idea of how the grammar looks for ANTLR.
I used the ANTLR grammar for parsing CSS in DiffLens (https://github.com/marketplace/difflens). DiffLens uses the typescript compiler itself to parse TS and JS.
I've also used Roslyn to parse C# (and F#). I wonder if the ruby compiler itself exposes a parser.
In I Built a Ruby ParserWhy use types? Why not introduce built in parsers to provide validations instead? (i.e. https://github.com/antlr/grammars-v4)
I think hush is going in the wrong direction. The majority of shell automation is associated with running IaC and container images / orchestration tools.
Shell scripts don't need to follow functional programming or OOP. They need to be container-oriented / VM-oriented / image-oriented with a conformation to YAML notation as this is already the adopted norm for containers and IaC.
In Hush, a modern shell scripting languageI believe antlr has grammars for other sql syntaxes (sqlite, tsql, etc): https://github.com/antlr/grammars-v4/tree/master/sql
In Open Source SQL ParsersI’ve been playing with ANTLR[1] and pretty happy with the generated parser. You can find sql grammar on GitHub[2]
[1] https://www.antlr.org/
[2] https://github.com/antlr/grammars-v4
In Let's write a compiler, part 5: A code generatorShowing the 15 most recent of 23 sources. Enable JavaScript to search and browse every indexed mention.