01 — Parser Generator
LL(k) parser generator for context-free grammars. Generates a parser and a full AST (Abstract Syntax Tree) for Java & C++ from a single grammar definition.
LL(k) parser generation for Java, C++ & Rust
Development tools based on MODELLING
Developer tools for Gradle and VSCode, based on Java, C++ and Rust. The toolkit includes an LL(k) parser generator, server launchers for VSCode and build pipelines for Gradle.
$ git clone https://github.com/hivevm/cc
Calc.g
// LL(k) grammar — generates a parser + AST grammar Calc; expr : term (('+' | '-') term)* ; term : factor (('*' | '/') factor)* ; factor : NUMBER | '(' expr ')' ; NUMBER : [0-9]+ ('.' [0-9]+)? ; WS : [ \t\r\n]+ -> skip ;
terminal
$ hivevm-cc generate Calc.g --target java,cpp
Parsing grammar Calc.g…
✓ LL(k) analysis complete (k=2)
✓ Parser → java/CalcParser.java
✓ AST → cpp/CalcNode.hpp
→ 2 targets built in 0.4s
watching grammar for changes
Generates and builds across your stack
- Java
- C++
- Rust
- Gradle
- VSCode
- CommonMark
Toolkit
Everything a modelling toolchain should handle
HiveVM owns the model-and-generate layer — grammars, documentation and build orchestration — so your repository stays focused on intent, not boilerplate.
02 — Manual Generator
Manual generator for collections of Markdown documents. Supports the CommonMark syntax to turn a folder of files into one coherent manual.
intro.mdrendered
config.mdrendered
draft.mdskipped
GitHub 03 — Gradle Workflow
A Gradle-based CD/CI pipeline engine. Define a single workflow that orchestrates heterogeneous build systems — Gradle, CMake and Cargo side by side.
buildgradle assemble8.1s
testgradle check12.4s
packagecmake install5.0s
Multiple targets, one model
The same grammar emits idiomatic Java and C++ — keep one source of truth and let HiveVM project it onto each language.
VSCode server launchers
Server launchers wire your generated tooling straight into VSCode, so language features light up as soon as the model changes.
Developer experience
Definitions that read like the thing they describe
Grammars, documents and pipelines are plain declarative files. Describe the intent once and let HiveVM generate the parser, the manual and the build.
- One LL(k) grammar generates a parser and AST for both Java and C++
- Plain CommonMark files compile into a single navigable manual
- One workflow file orchestrates Gradle, CMake and Cargo together
grammar Calc; expr : term (('+' | '-') term)* ; term : factor (('*' | '/') factor)* ; factor : NUMBER | '(' expr ')' ; NUMBER : [0-9]+ ;
plugins { id 'org.hivevm.devops' version '1.0' } workflow { stage('build') { gradle 'assemble' } stage('test') { gradle 'check' } stage('package') { cmake 'install' } stage('publish') { onBranch 'main' } }
# User Manual Built from a collection of **CommonMark** files. - [Getting started](./start.md) - [Configuration](./config.md) - [Grammar reference](./grammar.md)
Build orchestration
One workflow across heterogeneous build systems
The Gradle DevOps engine defines a single pipeline for projects that mix Java, C++ and Rust — running each stage on the right build tool and streaming structured logs as it goes.
gradle :workflow:run
running
build8.1s
gradle assemble
test12.4s
gradle check
package5.0s
cmake install · cargo build
publish2.2s
INFO workflow.start branch=main
INFO build.ok gradle :core:assemble
WARN test.flaky retry attempt=2
INFO package.ok cmake + cargo
INFO workflow.end status=success 27.7s
Open source
Built in the open, on GitHub
Every HiveVM tool lives in its own public repository. Read the source, file issues or build from it — the whole toolkit is open.
hivevm/cc
LL(k) parser generator for context-free grammars. Generates parser and AST for Java & C++.
Open repository
hivevm/doc
Manual generator for collections of Markdown documents. Supports the CommonMark syntax.
Open repository
hivevm/gradleDevOps
A Gradle-based CD/CI pipeline engine. Define a workflow for heterogeneous build systems.
Open repositoryModel your next toolchain
Start from a grammar, a folder of Markdown or a build workflow. HiveVM turns the model into a parser, a manual or a pipeline — for Java, C++ and Rust.
