Contributing Code
Can I Help Fix a Bug?
Sure!
Have a look at the issue report: if the issue is assigned to someone, they’re on it! Maybe you can find something else to work on, or you can contact the person it’s assigned to to see if they need a hand.
If the issue is not assigned to anyone, add a comment in the issue indicating you’d like to work on resolving the issue and go for it!
How to Submit Some Code?
Whether you have a fix for an issue, some improved test cases, or a brand new feature, we welcome your contributions in the form of pull requests.
Your contributions are governed by the GitHub TOS section 6 which indicate that your contributions are made under the same license as the project.
Furthermore, by making a contribution to the project, you certify that you have the right to submit to the project as detailed in the Developer Certificate of Origin.
Follow this process if you’d like your work considered for inclusion in the project:

Fork the project, clone your fork, and configure the remotes:
# Clone your fork of the repo into the current directory git clone https://github.com/<yourusername>/<reponame> # Navigate to the newly created directory cd <reponame> # Assign the repo to a remote called "upstream" git remote add upstream https://github.com/<upstreamowner>/<reponame>

If you cloned a while ago, get the latest changes from upstream:
git checkout <devbranch> git pull upstream <devbranch>

Create a new topic branch (off the main project development branch) to contain your feature, change, or fix:
git checkout b <topicbranchname>

Commit your changes in logical chunks. Please adhere to these git commit message guidelines. Use Git’s interactive rebase feature to tidy up your commits before making them public.

Locally merge (or rebase) the upstream development branch into your topic branch:
git pull [rebase] upstream <devbranch>

Push your topic branch up to your fork:
git push origin <topicbranchname>

Open a Pull Request with a clear title and description.
Once submitted, your Pull Request is reviewed and you will receive some feedback to make sure that it fits in with:
 the roadmap for the project
 the architecture of the project
 the coding Style Guide used by the project
After it has has been accepted, you Pull Request will be merged into the main branch.
Thank you for your contribution!
Overview of the MathLive Repository
Here’s an overview of the MathLive code structure, designed to help you understand the project if you’re interested in contributing:
Source Directory (src
)
The source directory contains all the essential code for MathLive:
core
: Handles parsing and rendering LaTeX into HTML markup.coreatoms
: Contains definitions for rendering and generating LaTeX for mathematical layout objects (fractions, delimiters, arrays, etc.).coredefinitions
: Contains definitions of supported LaTeX commands, interpreting their arguments and mapping them to appropriate atoms.editor
: Utilities to handle specific features of the editor, such as virtual keyboard, localization, keybindings, etc.editormathfield
: Manages user interactions with the math field, including keyboard and pointer input.editormodel
: Represents the state of the math expression, including its content and selection, along with the code necessary to modify it.addons
: Miscellaneous.
Core Components
core
: Contains the code to parse and render LaTeX. It usescoredefinitions
to interpret LaTeX commands andcoreatoms
to render them.coreatoms
: Contains the definition of supported layout primitives, each being a subclass of the baseAtom
class.coredefinitions
: Contains the definitions of supported LaTeX commands, specifying how to interpret each command.
Editor Components
editormathfield
: Contains the code to handle user interactions with the math field, including mouse or touch and keyboard input.editormodel
: Contains the code for theModelPrivate
class, representing the state of the math field, including its content and selection.
Documentation
CONTRIBUTOR_GUIDE.md
: A comprehensive guide for developers who want to contribute to the project. It includes details about setting up the development environment, code structure, language and coding style, bundling, browser support, accessibility, and architecture.
Commands Reference
COMMANDS_REFERENCE.md
: MathLive supports over 800 standard TeX and LaTeX commands. A complete list can be found in this document.
Conclusion
The MathLive project is wellstructured, with clear separation of concerns between core functionalities, rendering, and user interactions. Understanding these components will provide a solid foundation for contributing to the project, whether you’re fixing a bug or adding a new feature.
MathLive Theory of Operations
Here’s a basic description of the algorithm used by MathLive to render and edit an equation:
1. Parsing LaTeX Input
 Lexer: Converts the LaTeX string into tokens (
Token[]
).  Parser: Uses the tokens to create a tree of mathematical symbols or “atoms” (
Atom[]
), interpreting LaTeX commands with the help ofcoredefinitions
.
2. Rendering LaTeX to HTML
 Atoms to Boxes: The atoms are turned into “boxes” (
Box[]
), which are virtual DOM nodes representing layout units.  HTML/SVG Markup Generation: The boxes are rendered into HTML/SVG markup, using TeX layout algorithms to ensure highquality rendering.
3. Editing and User Interaction
 Mathfield Class: Captures keyboard and pointing device events, presenting an appropriate user interface.
 Model Class: Encapsulates operations on the tree of atoms, including adding/removing content and tracking/modifying the insertion point and selection.
 Editor Components: Handle specific user interactions, such as virtual keyboards, localization, texttospeech, and more.
4. Accessibility and Alternate Renditions
 Spoken Text Generation: MathLive can generate spoken text representations of the formula, with prosody hints for natural texttospeech rendition.
 Accessibility Support: Includes keyboard shortcuts for aural navigation and understanding of complex formulas, and support for screen readers.
5. Architecture Overview
 Core: Handles rendering of LaTeX to HTML markup, following TeX algorithms for accurate rendering.
 Editor: Manages user interaction with the formula, using Core for rendering and Model for manipulating the inmemory representation.
Conclusion
The MathLive algorithm is a multistep process that involves parsing LaTeX input, rendering it into HTML/SVG markup, and providing a rich editing interface with accessibility support. The architecture is divided into Core and Editor components, each handling specific aspects of rendering and user interaction.
This highlevel overview provides a basic understanding of how MathLive renders and edits equations. For a more indepth exploration, the source code and contributor documentation would be valuable resources.
Compute Engine Repo and Theory of Operations
Overview
The repository is primarily focused on mathematical computation and provides a robust engine for symbolic and numeric computations. It’s structured into several key parts:
 Compute Engine: Core logic for computations.
 Library: Mathematical functions and constants.
 LaTeX Syntax: Parsing and handling LaTeX expressions.
 Cortex: Additional documentation and details.
 Docs: Guides and assumptions related to symbolic computing.
 Math JSON: JSON format for mathematical expressions.
Theory of Operations
Compute Engine
The compute engine is the heart of the system, providing symbolic and numeric computations. It’s designed to be extensible and can handle a wide range of mathematical expressions.
Library
The library contains predefined mathematical functions, constants, and symbols. It’s a vital part of the system, allowing users to perform complex calculations without having to define basic mathematical constructs.
LaTeX Syntax
This part of the system focuses on parsing and handling LaTeX expressions. It translates LaTeX into a format that the compute engine can understand, bridging the gap between humanreadable notation and machine processing.
Math JSON
Math JSON is a specific JSON format designed to represent mathematical expressions. It’s a standardized way to communicate mathematical constructs between different parts of the system or with external applications.
Conclusion
The cortexjs/computeengine repository is a comprehensive solution for mathematical computations, offering a wide range of features from basic arithmetic to complex symbolic calculations. Its modular design and extensive documentation make it a versatile tool for anyone working with mathematical expressions, whether in LaTeX or other formats.