`Commoji`

This file contains the
v3.0.0 • 19 Mar 2026
specification and documentation of Commoji.

🚀 Head to the Revisions or Releases page to browse the other versions.

🐉 Commoji is a psychology-based emoji commit convention that reduces cognitive load and turns Git history into a visually scannable and instantly queryable log with deterministic prefixes powering commands like git bug, git breaking, and git ui. 🏷️

One glance reveals what changed. One alias queries the whole history.

Features

Commoji blends semantic clarity with visual expressiveness in commit messages to make intent easier to convey. It's not just a tagging system; it's a psychology-based visual grammar for storytelling in code.

✨ Visual Expressiveness: Emojis provide instant, colorful cues that make commit histories pop and easier to scan at a glance. Eye-tracking research confirms emojis are detected parafoveally (before direct fixation) and increase skipping rates of nearby text while reducing total reading time.
🔍 Queryable History: Deterministic prefixes enable instant queries like git bug, git breaking, and git ui.
🏷️ Semantic Orthogonality: Distinct domain prefixes and operational verbs ensure every message clearly conveys purpose without tautological ambiguity.
📊 Reduced Cognitive Load: Fixed format lowers mental effort, allowing quick understanding of changes in logs or diffs. Congruent emojis improve processing fluency and message understanding compared with plain text.
🧠 Intuitive Design: Draws on psychological principles like pop-out effect and chunking for a more natural reading experience.
🧩 Structured Decision-Making: Forces explicit choices along orthogonal axes (domain vs operation), turning subjective labeling into a low-friction process.
🚀 Tooling Compatibility: Designed to work with parsers, linters, and changelog generators; see the Tooling section for ready-to-use examples.

The Psychology

Commoji originated from real-world attempts to make dense commit logs easier to skim quickly. Its design choices (visual anchors, strict domain:operation separation, predictable structure) align closely with well-documented mechanisms of visual perception and cognitive load reduction. The thinking that originated from earlier patterns used in projects like AdVoid, where emoji prefixes proved highly effective for instantly identifying module-specific changes in dense histories, evolved to a science-based system that Commoji is today.

Here are the key psychological principles that power the system:

Visual Indexing & Attentional Capture (Treisman & eye-tracking research)
Emojis act as high-contrast pre-attentive anchors. Their color and shape differences allow rapid detection during skimming – often via parafoveal preview – guiding attention to relevant commits before full text reading begins. Eye-tracking studies confirm congruent emojis are processed parafoveally (like words), are skipped more often than incongruent ones, and reduce total fixation time on the preceding target word (Barach et al., 2021).
Semantic Orthogonality (Lexical Semantics & Cognitive Science)
Strict noun–verb separation eliminates redundancy. Non-overlapping semantic dimensions reduce classification effort and enable near-instant mental model construction - a principle from structural linguistics applied directly to commit grammar (Lyons, J., 1977).
Gestalt Grouping & Chunking The emoji + tag creates immediate perceptual unity (proximity + similarity), turning each commit into a reliable, bite-sized chunk.
Cognitive Load Reduction & Processing Fluency
Predictable prefix + concise object offloads parsing effort. Once learned, reading feels subjectively effortless and fast (familiarity heuristic). Messages with congruent emojis are rated as more understandable and require less cognitive effort than plain text (Daniel & Camp, 2020; Boutet et al., 2021).
Dual-layer Signaling
Emoji and matching tag reinforce the same category without overload – increasing clarity in dense, fast-scrolling logs through multimodal (visual + verbal) encoding.

This strict separation turns commit writing into a lightweight, repeatable decision framework rather than an ad-hoc prose exercise. In short, Commoji doesn't just look nicer, it works with the brain instead of against it.

Note that emojis require UTF-8 support in the terminal and Git client to render correctly - this is standard in all modern environments, but worth verifying. Shortcodes (e.g. :sparkles:) are provided in the shortcode reference under the Prefixes table as a human-readable lookup aid and must never appear in commit subjects.

Usage

Format

Commoji relies on a strict Noun/Action Separation to eliminate repetition and enforce semantic orthogonality.
The prefix (emoji + tag) identifies the domain (what area of the codebase), the verb identifies the operation (what was done to it), and the object identifies what specifically was affected.

Core Format

No scope (global change or scope unknown):
<prefix>: <verb> <object>
With scope (specific module, component, or directory):
<prefix>(<scope>): <verb> <object>

Spacing & Casing Rules (mandatory)

The entire <prefix> must be taken exactly from the Prefixes table (e.g. ✨ feature, 🐛 bug, 🔨 logic, etc.)
No space between the prefix (or the closing parenthesis of a scope) and the colon :
Exactly one space after the colon :
scope is always lowercase with hyphens (e.g. user-profile, payment-gateway)
verb is always lowercase imperative present tense; selected from the Verbs table
object must be lowercase by default. Capitalization is reserved strictly for Proper Nouns, Brands, or Technical Identifiers to preserve semantic accuracy

Optional

Reference GitHub issues/PRs with #123 in the object or body (e.g. fix login crash (#234) or in body: Closes #234).

Prefix Rendering

Commit subjects must use the actual UTF-8 emoji as shown in the Prefixes table.
Shortcodes (e.g. :sparkles:, :bug:, :lipstick:) are provided in the shortcode reference table as a human-readable reference only - for looking up or identifying emojis - and must never appear in commit subjects. Using shortcodes in commits silently breaks all git aliases.

The <prefix> must come from the official Prefixes table. The verb follows the rules defined in the Verbs section. This rigid prefix structure is what enables fast visual scanning and future automated tooling.

Breaking Changes

To indicate a breaking change (API removal, incompatible API change, removed feature, etc.), place an exclamation mark (!) immediately before the colon.
For unscoped commits, the ! attaches directly to the prefix.
For scoped commits, the ! must immediately follow the closing parenthesis.
The ! is optional - use it only when the change truly breaks existing consumers or contracts in that domain.

Syntax

No scope
<prefix>!: <verb> <object>
With scope
<prefix>(<scope>)!: <verb> <object>

Examples (fully compliant with Format rules)

🐛 bug!: update login response format
💄 ui!: remove deprecated dark mode toggle
🔨 logic(auth)!: rename internal token keys
📦 deps(user-profile)!: remove lodash v4

Why the `!` goes before the colon?

Placing the ! immediately before the colon (after prefix and optional scope) follows established conventions while still keeping the breaking signal in the visual prefix. This ensures instant recognition during scanning and better compatibility with conventional commit parsers.

Recommended commit body

When a change is breaking, it is strongly recommended to explain the impact in the body using the conventional format:

**BREAKING CHANGE**: legacy OAuth1 tokens are no longer supported.  
Migrate to OAuth2 before v2.0.0.

Prefixes

Commoji defines a fixed set of prefixes (emoji + tag) that act as Nouns representing the domain or entity being modified. These prefixes are immutable - never invent, swap, or separate the emoji from its tag. Always use the exact UTF-8 emoji as shown; shortcodes are for lookup only and must never appear in commit subjects.

Prefix	Category	Domain / Purpose
✨ feature	Core	New capabilities or features
🐛 bug	Core	Faults, defects, or issues
🔨 logic	Core	Code architecture and internal structure
🔥 debt	Core	Technical debt and dead code
🐣 repo	Core	Initial setup or repository metadata
💄 ui	UI & Experience	Visual elements, styles, and interface polish
🧠 ux	UI & Experience	User experience flows, interactions, and behavior
🎨 assets	UI & Experience	Static files, images, fonts, and icons
🌐 i18n	UI & Experience	Locale resources and internationalization support
🦯 a11y	UI & Experience	Accessibility (a11y) requirements
📚 docs	Docs & Quality	Documentation and guides
✅ spec	Docs & Quality	Test coverage, assertions, and validation rules
📐 types	Docs & Quality	Type definitions, interfaces, and schemas
💾 data	Data	Database schemas, seeds, queries, and migrations
📦 deps	Build & Ops	Dependencies and packages
🚀 env	Build & Ops	Deployment environments and pipeline infrastructure
👷 ci	Build & Ops	Continuous integration workflows
🏭 build	Build & Ops	Build system or compiler instructions
🔩 config	Build & Ops	System and environment settings
📊 metrics	Performance	Performance, efficiency, and metrics
🔐 security	Security	Security vulnerabilities and protective measures
🔧 chore	Maintenance	Miscellaneous maintenance and chores
⌛ history	Maintenance	Git commit history and its state
🔀 branch	Maintenance	Branch structure and merge points
🔬 experiment	Maintenance	Experimental prototypes

Table 1. Commoji's prefix system (Domains)

Shortcodes

Reference

Prefix	Shortcode
✨ feature	`:sparkles:`
🐛 bug	`:bug:`
🔨 logic	`:hammer:`
🔥 debt	`:fire:`
🐣 repo	`:hatching_chick:`
💄 ui	`:lipstick:`
🧠 ux	`:brain:`
🎨 assets	`:artist_palette:`
🌐 i18n	`:globe_with_meridians:`
🦯 a11y	`:white_cane:`
📚 docs	`:books:`
✅ spec	`:white_check_mark:`
📐 types	`:triangular_ruler:`
💾 data	`:floppy_disk:`
📦 deps	`:package:`
🚀 env	`:rocket:`
👷 ci	`:construction_worker:`
🏭 build	`:factory:`
🔩 config	`:nut_and_bolt:`
📊 metrics	`:bar_chart:`
🔐 security	`:closed_lock_with_key:`
🔧 chore	`:wrench:`
⌛ history	`:hourglass:`
🔀 branch	`:twisted_rightwards_arrows:`
🔬 experiment	`:microscope:`

Important

Choose the prefix that matches what changed, not why it was changed.
A cache layer added for performance reasons is still 🔨 logic - it changes architecture. Adding a profiling wrapper or tracing span is also 🔨 logic - it changes code structure. Use 📊 metrics only when the commit touches measurement tooling, benchmarks, or reporting infrastructure itself.

🎨 assets is for static files (images, fonts, icons, SVGs). Use 💄 ui when changing how the interface looks or behaves - styles, components, layouts. If you're swapping an icon file, that's 🎨 assets; if you're restyling the button that uses it, that's 💄 ui.

🔧 chore is a catch-all - use it only when no other prefix fits, and aim to keep it below 25–30% of commits.

🔥 debt is for deliberate removal or resolution of known bad code — dead code, deprecated APIs, legacy workarounds. Use 🔧 chore only for routine maintenance that doesn't fit any other domain (e.g. updating .gitignore, renaming config files). If you're deleting code, it's almost always 🔥 debt.

Examples

✅ 🐛 bug: fix memory leak in caching layer
✅ 🔥 debt: remove deprecated v1 API controllers
❌ 🚨 fix: memory leak – 🚨 fix is not a valid prefix from the table
❌ ✨ bug: fix memory leak – wrong prefix (must use the exact combination shown in the Prefix column)

Scope

The scope narrows the commit's focus to a specific module, component, feature, or directory. This lets readers instantly know where the change applies without opening the diff. Unlike some conventions, Commoji scopes must not duplicate or semantically overlap the prefix tag - the prefix already identifies the domain, so the scope should only add location information.

Rules (mandatory)

Use the exact name of the relevant folder, module, or component (e.g. auth, payment-gateway, user-profile).
Always lowercase with hyphens for multi-word scopes.
Omit the scope entirely when:
- the change affects the whole project, or
- the scope would be identical or semantically duplicate the tag in the prefix (e.g. 📊 metrics(performance), 💄 ui(styles)).
Avoid broad/generic scopes such as core, misc, utils, main – they defeat the purpose of scoping. If no specific scope applies, omit it entirely and keep the correct domain prefix.
When in doubt, omit the scope - a clean <prefix>: <verb> <object> is always preferred over a vague or redundant (<scope>).

Examples (fully compliant with Format & orthogonality)

✅ ✨ feature(payment-gateway): add Stripe webhook handler
✅ 📚 docs(auth): add table of contents to README
✅ 🔨 logic: refactor token validation
❌ 💄 ui(ui): update button styles – scope duplicates tag
❌ 📊 metrics(performance): optimize startup time – semantic duplication
✅ 🔨 logic: update utility parsers – correct domain, scope omitted when too broad
❌ 🔧 chore(utils): update utility parsers – domain replaced by chore to avoid scoping decision

Verbs

Verbs represent the operation (the “how”) applied to the domain tag.
To ensure consistency and fast scanning, verbs must be selected from the official table below. This enforces semantic orthogonality between domain (tag) and operation.
If a change feels like it falls between two categories, select the verb representing the primary intent and utilize the commit body for technical nuances.

Verb	Action Purpose
add	Introduce a new element
update	Modify an existing element
remove	Eliminate something
rename	Change a name or label
move	Reposition without modifying content
implement	Build out functionality
fix	Correct something that is not working as expected
refactor	Reorganize code without changing its output
optimize	Improve throughput or reduce resource usage
test	Verify that code works as intended
prepare	Set up or stage for an upcoming release
release	Publish or ship a version
revert	Undo a previous change
integrate	Combine separate code streams or systems
clean	Purge unused or obsolete elements
translate	Convert or adapt content for a target language
generate	Create generated / derived files or code
bump	Increment or set a specific version number
upgrade	Move to a newer major/minor version
migrate	Move or adapt code/data to a new format or platform
harden	Strengthen code and systems against threats
enable	Activate a feature, flag, or capability
disable	Deactivate a feature, flag, or capability
deprecate	Mark something as obsolete and scheduled for removal
split	Divide one module, file, or component into multiple

Table 2. Commoji's verbs (Operations)

Examples (fully compliant)

✅ 👷 ci: add deployment smoke test
✅ 📚 docs: add payment flow guide
✅ 🔐 security: harden API endpoints against XSS
✅ 🔬 experiment: add Redis caching prototype
✅ 🔀 branch: integrate feature/auth-rewrite
✅ ⌛ history: revert accidental merge commit
❌ 🔬 experiment: experiment with caching – experiment is not in the Verbs table
❌ 🔀 branch: merge main – merge is not in the Verbs table
❌ 🔨 logic(auth): refactored token validation – wrong tense

Tip

Quick verb cheat-sheet

New → add / implement / generate (derived or output files only)
Change → update / refactor / fix / migrate / enable / disable / deprecate
Split → split (divide one module, file, or component into multiple)
Delete → remove / clean

update vs migrate: use update when modifying an existing element in place. Use migrate only when moving or adapting code, data, or configuration to a structurally different format, platform, or system - e.g. migrate user schema to UUID, migrate config to TOML. If no structural change occurs, it's update.

Object

The object is a concise noun phrase that identifies what specifically was affected by the operation.
It completes the sentence started by the prefix + verb while staying short and scannable.

Rules (mandatory for consistency)

Use a specific noun phrase (never repeat the tag or verb semantically).
Keep the entire summary line (prefix through object) under 72 characters whenever possible; aim for ≤ 65 characters for best readability in dense logs and small screens.
The object must be lowercase by default to promote uniform, scannable logs. Capitalize only:
- Proper nouns (names, brands: Stripe, React, Vite)
- Acronyms and technical terms that are conventionally capitalized (API, XSS, OAuth2, URL, ToC, JSON, HTML)
- Do not capitalize the first word of the object (avoid sentence-style capitalization) for consistency across the history.
Never turn the object into a full sentence or list – use the commit body for details.
Avoid words already encoded by the verb - add new X is redundant since add implies new; write add X instead.

Examples (fully compliant with all previous rules)

Summary	Valid	Reason
`📚 docs(api): add table of contents`	✅	Specific noun phrase
`🐛 bug: fix null pointer in login`	✅	Identifies exact failure point
`📊 metrics: add startup time benchmark`	✅	Adds measurement, squarely in metrics domain
`📚 docs: update installation guide`	✅	Clear subsection
`📚 docs: update docs`	❌	Object too broad / repeats tag
`📦 deps: bump lodash to 4.17.21`	✅	Version pinned, no overlap
`📦 deps: upgrade zep from 6.1 to 6.3`	✅	Specific version range, clean domain+operation
`✨ feature: add mode`	❌	Ambiguous object
`🐛 bug: fix bug`	❌	Repeats tag
`📊 metrics: optimize performance`	❌	Vague object

Table 3. Commoji's object examples

When a change has many small parts, pick the single most important noun phrase for the summary and list the rest in the body:

📚 docs: add table of contents

- generated ToC for every heading
- updated all internal anchor links
- fixed minor typos in code blocks

Commit Body

The commit body is optional but strongly recommended when the change needs more context, especially for breaking changes, complex refactors, or when referencing issues.

Guidelines

Leave a blank line after the summary line
Keep each line under 72 characters
Use bullet points (- ) for multiple changes or explanations
Common trailers (auto-linked by GitHub and many tools):
- Closes #123 / Fixes #456
- Co-authored-by: Name <email>

Example

💄 ui!: remove deprecated dark mode toggle

**BREAKING CHANGE**: the dark mode toggle has been removed due to accessibility issues.
Users should now rely on their system preference.

- removed legacy toggle component
- updated documentation and settings panel

Closes #234

Querying

Because Commoji prefixes are fixed, deterministic, and always at the start of the subject line, history can be queried with high precision using simple git log --grep commands - essentially turning the log into a lightweight tagged database.

These queries are highly reliable for single-domain aliases: the emoji + tag combination is unique and non-overlapping, and the ^ anchor ensures subject-line matching for standard prefix queries. The breaking alias searches the full commit message and may produce rare false positives if body text incidentally matches the pattern.

Recommended Git Aliases

Add the following to the global ~/.gitconfig (or project .git/config):

[alias]
    # Single-domain queries
    feat     = log --grep="^✨ feature"  --oneline --decorate --color --graph
    bug      = log --grep="^🐛 bug"      --oneline --decorate --color --graph
    ui       = log --grep="^💄 ui"       --oneline --decorate --color --graph
    docs     = log --grep="^📚 docs"     --oneline --decorate --color --graph
    deps     = log --grep="^📦 deps"     --oneline --decorate --color --graph
    security = log --grep="^🔐 security" --oneline --decorate --color --graph
    chore    = log --grep="^🔧 chore"    --oneline --decorate --color --graph

    breaking = log --grep="^[^:]+!:" --extended-regexp --oneline --decorate --color --graph # searches full message, not subject only
    breaking-this-week = log --grep="^[^:]+!:" --since="1 week ago" --oneline --decorate --color --graph # same caveat

    # Scoped variants (more precise, ignores object/body matches)
    feat-scoped = log --grep="^✨ feature(" --oneline --decorate --color --graph
    bug-scoped  = log --grep="^🐛 bug("    --oneline --decorate --color --graph

    # Compound / recent / filtered examples
    recent-bugs = log --grep="^🐛 bug" -n 15 --oneline --decorate --color --graph
    core-changes = log --grep="^(✨ feature|🐛 bug|🔨 logic|🔥 debt)" --extended-regexp --oneline --decorate --color --graph

Warning

The breaking and breaking-this-week aliases search the full commit message including the body, not just the subject line. If body text incidentally contains !: (e.g. in code samples or prose), rare false positives may appear. All other single-domain aliases are subject-line anchored via ^ and are not affected.

Why these work so well

^ anchors to start of line → no false positives from object or body for single-domain aliases (the breaking alias searches the full message - see caveat above)
Exact emoji + tag + space → no overlap with other prefixes
--extended-regexp (-E) allows clean OR patterns when needed
--graph --color --decorate makes output readable and beautiful

Pro tip

Combine with other flags for "SQL-like" power:

# Bugs by the current user this month
git bug --author="$(git config user.name)" --since="1 month ago"

# UI changes since last release
git log v1.2.0.. --grep="^💄 ui" --oneline --decorate --color --graph

These aliases are optional but highly recommended - they unlock the full scanning speed promise of Commoji.

Tooling

Commoji is built first and foremost for human readers. Full 100% automated enforcement of every rule (especially semantic orthogonality, verb choice, and object quality) is inherently difficult with today's conventional linters.

Current possibilities

Standard tools like commitlint can reliably enforce the structural parts of the spec:

Presence of valid prefix from the Prefixes table
Lowercase scope
Exactly one space after the colon
Header length
Breaking-change ! placement

Deeper rules (verb appropriateness, avoiding semantic repetition in the object, etc.) cannot be perfectly validated automatically.

Recommended approach

Use the minimal commitlint config below for basic structural guardrails.
Rely on the upcoming official Commoji VS Code Extension (currently in development) as the primary tool for full guidance, interactive commit creation, real-time validation, and best compliance.

Minimal commitlint config (`.commitlintrc.js`)

module.exports = {
  extends: ['@commitlint/config-conventional'],
  parserPreset: {
    parserOpts: {
      headerPattern: /^(.+?\s[\w-]+)(?:\(([^)]+)\))?(!)?:[ ](.*)$/,
      headerCorrespondence: ['type', 'scope', 'breaking', 'subject']
    }
  },
  rules: {
    'type-enum': [
      2,
      'always',
      [
        '✨ feature',
        '🐛 bug',
        '🔨 logic',
        '🔥 debt',
        '🐣 repo',
        '💄 ui',
        '🧠 ux',
        '🎨 assets',
        '🌐 i18n',
        '🦯 a11y',
        '📚 docs',
        '✅ spec',
        '📐 types',
        '💾 data',
        '📦 deps',
        '🚀 env',
        '👷 ci',
        '🏭 build',
        '🔩 config',
        '📊 metrics',
        '🔐 security',
        '🔧 chore',
        '⌛ history',
        '🔀 branch',
        '🔬 experiment'
      ]
    ],
    'type-case': [0],   // disabled - commitlint can't handle emoji-prefixed types
    'scope-case': [2, 'always', 'lower-case'],
    'subject-case': [0], // disabled - object casing is spec-managed (proper nouns etc.)
    'subject-empty': [2, 'never'],
    'subject-full-stop': [2, 'never'],
    'header-max-length': [2, 'always', 72],
    'type-empty': [2, 'never']
  }
}

Canonical Header Regex

For use outside commitlint - Git hooks, custom parsers, changelog generators, CI scripts:

/^(.+?\s[\w-]+)(?:\(([a-z][a-z0-9-]*)\))?(!)?:[ ](.+)$/

Group	Captures	Example
`$1`	Full prefix (emoji + tag)	`✨ feature`
`$2`	Scope (optional)	`payment-gateway`
`$3`	Breaking `!` (optional)	`!`
`$4`	Subject (verb + object)	`add Stripe webhook handler`

Git Hook (`commit-msg`)

Drop-in hook for projects not using Husky or lint-staged. Save as .git/hooks/commit-msg and make it executable (chmod +x .git/hooks/commit-msg). Note that this validates structural format only - verb table compliance and semantic orthogonality require the Commoji VS Code Extension.

#!/bin/sh
# Commoji commit-msg hook - validates header structure

REGEX='^.+[[:space:]][a-zA-Z0-9_-]+(\([a-z][a-z0-9-]*\))?(!)?: .+$'
SHORTCODE_REGEX=':[a-z_]+:'
MSG=$(head -1 "$1")

if echo "$MSG" | grep -qE "$SHORTCODE_REGEX"; then
  echo "✖ Shortcode detected in commit subject: $MSG"
  echo "  Use the actual UTF-8 emoji instead of shortcodes (e.g. ✨ not :sparkles:)"
  exit 1
fi

if ! echo "$MSG" | grep -qE "$REGEX"; then
  echo "✖ Invalid Commoji format: $MSG"
  echo "  Expected: <prefix>[(<scope>)][!]: <verb> <object>"
  exit 1
fi

Examples

The table below demonstrates real commit messages that fully comply – or deliberately violate – the complete set of locked Commoji rules (Format, Prefixes, Scope, Verbs, Object, Breaking Changes, and semantic orthogonality).

Commit Message	Valid	Why
`🔨 logic(auth): refactor token validation`	✅	Imperative verb, no repetition
`🔩 config: update Redis connection timeout`	✅	Specific object, correct domain usage
`📚 docs: add payment flow guide`	✅	Concise object, unambiguous docs domain
`🔐 security: harden API endpoints against XSS`	✅	Valid table verb, precise object
`✨ feature(payment-gateway): add Stripe webhook handler`	✅	Valid scope, specific object
`📊 metrics: optimize Redis cache eviction`	✅	Specific object, clean domain+operation
`🔥 debt: remove deprecated v1 controllers`	✅	Precise object, correct domain usage
`🐛 bug!: update login response format`	✅	Breaking change without scope
`📦 deps(user-profile)!: remove lodash v4`	✅	Breaking change + multi-word scope
`📚 docs: update docs`	❌	Object repeats tag (violates orthogonality)
`✨ feature: new payment modal`	❌	Missing verb - object must be preceded by a verb
`🐛 bug: Fix Login Bug`	❌	Capitalized verb + object repeats domain
`🔨 logic(auth): refactored token validation`	❌	Past tense (must be imperative present)
`💄 ui(ui): update button styles`	❌	Scope duplicates tag

Table 4. Commoji commit message examples

References

The psychological foundation of Commoji draws from well-established research in visual perception, cognitive psychology, information theory, and multimedia learning.

Classic Foundational Works

Lexical Semantics & Semantic Dimensions
Lyons, J. (1977). Semantics (Vol. 1). Cambridge University Press. (Foundational treatment of semantic fields and the orthogonality of lexical dimensions - the basis for non-overlapping domain/operation separation in structured vocabularies.)
Feature Integration Theory & Pop-out Effect
Treisman, A. M., & Gelade, G. (1980). A feature-integration theory of attention. Cognitive Psychology, 12(1), 97–136. https://doi.org/10.1016/0010-0285(80)90005-5
Gestalt Principles
Wertheimer, M. (1923). Laws of Organization in Perceptual Forms. Psychologische Forschung, 4(1), 301–350.
Koffka, K. (1935). Principles of Gestalt Psychology. Harcourt, Brace.
Cognitive Load Theory
Sweller, J. (1988). Cognitive load during problem solving: Effects on learning. Cognitive Science, 12(2), 257–285.
Sweller, J., Ayres, P., & Kalyuga, S. (2011). Cognitive Load Theory. Springer.
Multimedia Learning & Signaling Principle
Mayer, R. E. (2021). The Cambridge Handbook of Multimedia Learning (3rd ed.). Cambridge University Press.
(See especially chapters on the Signaling Principle and Reducing Extraneous Processing.)
Processing Fluency & Familiarity Heuristic
Schwarz, N. (2004). Metacognitive experiences in judgment and decision making. Journal of Consumer Psychology, 14(4), 332–348.
Chunking & Working Memory
Miller, G. A. (1956). The magical number seven, plus or minus two: Some limits on our capacity for processing information. Psychological Review, 63(2), 81–97.

The works above informed the consolidation of principles in the Psychology section. For eye-movement and parafoveal preview benefits supporting fast scanning of emoji-prefixed commits, see also Rayner, K. (1998). Eye movements in reading and information processing: 20 years of research. Psychological Bulletin, 124(3), 372–422.

Empirical Studies on Emoji Processing & Software Communication

Barach, E., et al. (2021). Are emojis processed like words?: Eye movements reveal the time course of semantic processing for emojified text. Psychonomic Bulletin & Review, 28(3), 983–997. https://doi.org/10.3758/s13423-020-01864-y
(Core evidence for parafoveal preview, skipping rates, and reduced fixation times – directly supports high-speed Git log scanning.)
Daniel, T. A., & Camp, A. L. (2020). Emojis affect processing fluency on social media. Psychology of Popular Media, 9(2), 208–213. https://doi.org/10.1037/ppm0000219
(Shows congruent emojis make messages subjectively easier and faster to understand.)
Boutet, I., LeBlanc, M., et al. (2021). Emojis influence emotional communication, social attributions, and information processing. Computers in Human Behavior, 119, 106722. https://doi.org/10.1016/j.chb.2021.106722
(Faster processing speed and better comprehension with congruent emojis.)
Rong, S., Wang, W., Mannan, U. A., et al. (2022). An empirical study of emoji use in software development communication. Information and Software Technology, 148, 106912. https://doi.org/10.1016/j.infsof.2022.106912
(Large-scale GitHub analysis: emoji prefixes speed up responses and improve organization in commits/PRs – perfect real-world validation for Commoji.)

Changelog

Read about the latest changes in the CHANGELOG.

License

Licensed under the MIT license.

Support

Engineering and documenting open-source projects involves a significant investment of time.

If this project or its implementation has provided value, support is greatly appreciated.

Thank you for supporting these efforts! 🙏😊

Author

Created by Igor Dimitrijević (@igorskyflyer).

Name		Name	Last commit message	Last commit date
Latest commit History 116 Commits
.github		.github
assets		assets
revisions		revisions
.commitlintrc.js		.commitlintrc.js
CHANGELOG.md		CHANGELOG.md
LICENSE		LICENSE
README.md		README.md

Uh oh!

Folders and files

Latest commit

History

Repository files navigation

Commoji

Table of Contents

Features

The Psychology

Usage

Format

Core Format

Spacing & Casing Rules (mandatory)

Prefix Rendering

Breaking Changes

Syntax

Examples (fully compliant with Format rules)

Why the ! goes before the colon?

Recommended commit body

Prefixes

Shortcodes

Scope

Rules (mandatory)

Examples (fully compliant with Format & orthogonality)

Verbs

Object

Rules (mandatory for consistency)

Examples (fully compliant with all previous rules)

Commit Body

Guidelines

Example

Querying

Recommended Git Aliases

Tooling

Current possibilities

Recommended approach

Minimal commitlint config (.commitlintrc.js)

Canonical Header Regex

Git Hook (commit-msg)

Examples

References

Classic Foundational Works

Empirical Studies on Emoji Processing & Software Communication

Changelog

License

Support

Related

Author

About

Topics

Resources

License

Uh oh!

Stars

Watchers

Forks

Releases 8

Sponsor this project

Uh oh!

Uh oh!

Contributors

Uh oh!

Languages

`Commoji`

Why the `!` goes before the colon?

Minimal commitlint config (`.commitlintrc.js`)

Git Hook (`commit-msg`)