Projects sharing features with The Super Tiny Compiler

A Small C Compiler

This project is a compiler development tutorial that provides a series of guides and exercises for building a complete compiler from scratch. It focuses on the implementation of a structured compilation pipeline to transform high-level source code into executable machine instructions. The project covers the creation of a machine code generator for specific processor architectures and a static analysis framework. This framework includes methodologies for implementing type checking and constant folding to verify logic correctness before the final execution phase. The instructional material enc

Bhai-lang is a TypeScript-based toy programming language and custom syntax interpreter. It functions as an educational language implementation designed to demonstrate core concepts of variable management, conditional logic, and execution flow. The project provides a custom command line interface and an interactive code playground for writing and testing scripts. It serves as a framework for programming language prototyping, allowing for the definition of custom syntax and execution logic. The system covers the full interpreter pipeline, including lexical analysis, recursive descent parsing,

UglifyJS2 is a suite of tools designed for parsing, beautifying, mangling, and minifying JavaScript code. It functions by converting source code into an abstract syntax tree to enable programmatic analysis and transformation, and it includes a dedicated generator for creating associated source maps. The project optimizes web production builds by compressing script logic and removing unreachable code. It utilizes name mangling to shorten variable and property names and implements a beautifier to reconstruct compressed scripts into a human-readable layout. The toolset covers broad capability a

JsonCpp is a C++ library for parsing, manipulating, and generating JSON data. It functions as a data interchange tool that provides a JSON parser to convert formatted text into structured data and a JSON serializer to transform internal data structures back into valid JSON strings. The library features the ability to preserve non-standard JSON comments during the deserialization and serialization process, which supports the management of human-readable configuration files. The project implements a tree-based internal representation for programmatic data access and uses a builder-based config

This project is a C language interpreter and a practical implementation of a programming language. It parses and executes C source code directly, removing the requirement for a separate compilation step. The interpreter is designed for self-hosting, meaning it is capable of interpreting its own source code to demonstrate recursive language processing and execution. The system covers the primary stages of language processing, including lexical analysis, recursive descent parsing, and tree-walk interpretation using an abstract syntax tree. It manages memory and scope through a dynamic symbol t

This project is a comprehensive functional programming curriculum and learning resource for Haskell. It provides sequenced educational paths and technical reference guides designed to take developers from beginner to advanced levels of proficiency. The project distinguishes itself through a deep focus on theoretical and technical foundations, offering detailed studies on type theory, category theory, and runtime internals. It includes a dedicated performance handbook for optimizing execution speed and memory management, as well as an ecosystem guide for managing development tools and editor c

Claudes C Compiler is a self-contained C compiler toolchain that parses source code, optimizes intermediate representations, and generates machine code without relying on external assemblers, linkers, or toolchain dependencies. It translates C source files directly into standalone executable binaries, object files, or assembly text across multiple hardware architectures. The project provides built-in assembly and linking capabilities, processing architecture-specific assembly text, encoding instructions, combining object files and static archives, resolving symbols, applying relocations, and

This library provides a parser and encoder for YAML 1.2 data structures, enabling the transformation of human-readable YAML strings into native JavaScript objects and arrays. It is designed to function as a cross-platform utility, ensuring consistent data processing across both server-side runtimes and client-side browser environments. Beyond its core library functionality, the project includes a command-line interface for automating data conversion tasks. This utility supports bidirectional transformation between YAML and JSON formats, allowing for the programmatic manipulation and exchange

sqlglot is a SQL parser and transpiler that represents queries as abstract syntax trees to enable structural analysis, modification, and semantic transformation. It functions as a dialect translator and query optimizer, converting SQL code between different database engines and simplifying syntax trees through rule-based normalization. The project provides a framework for defining custom SQL dialects by overriding tokenizers, parsers, and generators. It includes a lineage analyzer to track data flow from source tables through complex queries to identify the origin of specific columns. Additi

PegJS is a parsing expression grammar tool and JavaScript parser generator. It functions as a grammar compiler that transforms formal grammar specifications into executable JavaScript code for analyzing structured text and processing complex input strings. The system generates deterministic parsers that avoid the ambiguity of context-free grammars. It utilizes a packrat parsing model with memoization to ensure linear time complexity and employs recursive descent parsing to process input in a top-down hierarchical manner. The toolset supports the implementation of domain-specific languages an

JSHint is a JavaScript static analysis tool and linter designed to detect errors and enforce coding standards. It functions as a syntax validator that scans source code to identify potential logic problems and programming mistakes before the code is executed. The tool provides a command line interface for analyzing files and directories. It supports the export of analysis results into standardized formats such as Checkstyle for integration with external build tools. Analysis is managed through a system of linting rule management and environment global configuration. This includes the ability

VBA-JSON is a library designed for parsing and serializing JSON data within Visual Basic for Applications environments. It functions as an office automation data library, enabling legacy Microsoft Office applications to process structured data and interact with modern web services. The tool converts raw JSON text into native objects and collections, allowing developers to access and manipulate data using standard indexing and iteration methods. It also performs the reverse operation, transforming native language structures into JSON-compliant strings for exchange with external systems. By ha

syn is a Rust syntax tree parser and token stream converter. It serves as a toolkit for procedural macro development, providing a framework to parse Rust source code into structured syntax trees for analysis and transformation. The project enables the manipulation of Rust abstract syntax trees through specialized visitor and folder patterns for traversing and mutating nodes. It provides a bidirectional mapping that allows developers to convert token streams into structured trees and print those trees back into tokens for code generation. The library covers a broad range of syntax analysis ca

Acorn is a JavaScript parser that converts source text into a structured abstract syntax tree. It follows the ESTree specification to produce a standardized JSON tree format, enabling consistent analysis of code structure and language versions. The project features a plugin-based grammar extension system that allows the base parser to be extended with custom rules for experimental or non-standard language features. It also includes syntax error recovery, which inserts placeholder nodes into the tree when encountering invalid code to allow parsing to continue. The toolset covers static analys

Emmet is a markup code generator and web development productivity toolkit. It serves as an expansion engine that converts shorthand abbreviations and CSS-like selectors into full HTML, XML, and other markup structures. The project features a dedicated CSS shorthand expansion engine that transforms concise property codes into full style declarations, including the automatic generation of vendor prefixes and gradients. It distinguishes itself by offering a programmable expansion process through custom snippet definitions, abbreviation alias mapping, and script-based extensibility. The toolkit

N64Recomp is a static recompiler and binary-to-C translator designed to convert Nintendo 64 machine code and MIPS architecture binaries into C source code. This system functions as a game console decompiler that enables the native execution of legacy binaries on modern platforms by eliminating the need for runtime interpreters. The project distinguishes itself by translating specialized RSP microcode into executable source code to replace traditional microcode emulation. It employs a system of relocation macros and lookup tables to resolve relocatable memory overlays and dynamic program secti

Participle is a Go parser generator and toolkit for building language frontends. It provides a declarative grammar framework that uses reflection and struct tags to map input patterns directly into typed data structures. The library features a stateful lexical analyzer that employs state machines to handle nested or modal patterns. It includes a lexer code generator to produce optimized code, reducing runtime memory allocations and increasing throughput. The project covers recursive descent parsing with support for union types via sealed interfaces and custom parsing logic through interface-

js-beautify is a web language beautifier and rule-based code stylizer designed to standardize the indentation and layout of JavaScript, HTML, and CSS. It converts minified or obfuscated source code into a human-readable format to improve maintainability and readability. The system enforces consistent coding styles through global configuration files and programmatic options. It also supports local formatting overrides, allowing users to control behavior for specific sections of a file using embedded comment directives. The project provides capabilities for source code style enforcement and we

JSON5 is a parser and serializer for a human-readable configuration format that extends JSON. It serves as a JavaScript-based data parser that allows for a more flexible version of the JSON specification to simplify manual editing of data files. The project provides capabilities to support comments, trailing commas, and multi-line strings. It includes utilities to convert this extended syntax into standard JSON for compatibility with tools requiring strict specifications. The library covers data serialization, string parsing, and structural syntax validation. It also provides integration for

KaTeX is a typesetting library and web math renderer that transforms TeX and LaTeX mathematical notation into high-quality HTML and CSS for web browsers. It functions as a math notation parser and LaTeX to HTML converter, capable of operating as both a client-side library and a server-side math renderer to generate static HTML expressions. The project supports a wide range of specialized mathematical rendering, including chemical equation rendering, Bra-ket notation for quantum mechanics, and mathematical logic typesetting. It provides comprehensive controls for structural layouts such as mat

This is an educational tutorial that walks through implementing a complete JSON library from scratch in C. The project covers the full data lifecycle of JSON, including parsing text into structured in-memory representations, validating input against the specification, serializing data back into standard JSON output, and providing structured access to elements within parsed arrays and objects. The implementation is built around a hand-written recursive descent parser that processes JSON text by matching grammar rules to build a structured data tree. Parsed values are stored in a tagged union r

Prism is a JavaScript syntax highlighter and web-based code formatter. It functions as an extensible syntax engine designed to colorize and format code blocks on web pages, making various programming languages easier to read. The project processes raw code strings into styled HTML elements for use in frontend content rendering, technical documentation, and static site generation. It provides a modular system for adding custom language definitions and highlighting rules to a web-based code viewer.

highlight.js is a JavaScript syntax highlighter and client-side code formatter that transforms plain text source code into highlighted HTML for web display. It provides syntax highlighting across a wide variety of programming languages. The library includes an automatic language detector that identifies the programming language of a code block to apply the correct highlighting rules without manual tagging. It is designed for web worker compatibility, allowing the highlighting process to run in background threads to prevent the browser interface from freezing during the processing of large vol

yaml-cpp is a C++ library for parsing and emitting YAML 1.2 documents. It provides a complete YAML processing pipeline, from reading YAML content into a traversable node tree to writing in-memory data structures back as YAML text. The library represents parsed YAML as a mutable tree of typed nodes, supporting scalars, sequences, maps, and aliases. It uses a recursive-descent parser to build this node tree, and a stream-based emitter to generate YAML output incrementally. Template-based type conversion enables compile-time serialization between YAML nodes and C++ types, including support for c

PHP-Parser is a tool that converts PHP source code into an abstract syntax tree for static analysis and programmatic manipulation. It functions as a parser, a code generator, and a static analysis framework. The project enables the programmatic construction of abstract syntax tree nodes through a fluent interface and provides the ability to transform these trees back into formatted source code. It includes a serializer that exports abstract syntax trees to JSON format and reconstructs them from strings. The toolset covers several capability areas, including namespace resolution, constant exp

Movfuscator is an obfuscating compiler that transforms C source code into x86 machine code consisting exclusively of move instructions. It implements all program logic, arithmetic, and control flow using a move-only instruction set to hide the execution path and prevent reverse engineering. The project includes a move-only library that performs double precision floating point calculations without using native floating point instructions. It also features a translator that converts these move-only binaries into restricted data transfers and indexed addressing for compatibility with RISC archit