Khoj is an open-source personal AI assistant functioning as a 'second brain' for interacting with personal knowledge bases. It provides a chat interface allowing users to converse with various AI models about documents, notes, and connected data sources (local files, GitHub, Notion). The system supports multimodal capabilities including image generation, code execution, voice input/output, and computer operation through a modular agent architecture. Khoj features a Python/Django backend with FastAPI for API endpoints, a PostgreSQL database with pgvector for vector storage and search, and multiple frontends including a web application (React/Next.js), desktop client (Electron), mobile app (Android), and plugins for Obsidian and Emacs. The architecture emphasizes separation of concerns with distinct modules for file processing, embedding generation, conversation handling, tool integration, and user management.
This repository contains `clojure-mode`, an Emacs major mode for editing Clojure, ClojureScript, and related languages. The system provides syntax highlighting (font-lock), indentation, navigation, and a suite of refactoring commands directly in the editor. The architecture is a single large Emacs Lisp file (`clojure-mode.el`) with an additional extra font-locking package. It defines a base `clojure-mode` derived from `prog-mode`, plus derived modes for ClojureScript, ClojureC, ClojureDart, Joker, Jank, and EDN data files. Key entry points are the mode activation functions and interactive commands like `clojure-align`, `clojure-thread`, `clojure-cycle-privacy`, etc. The indentation engine uses a backtracking algorithm that walks up the sexp tree to apply contextual indent specs (shared with `clojure-ts-mode`). Font-locking is regex-based and extensible, with special handling for docstrings, discard macros, and character literals. The package depends only on standard Emacs libraries (`cl-lib`, `imenu`, `align`, `subr-x`) and requires Emacs 27.1+.
nix-doom-emacs-unstraightened is a Nix-based build system for Doom Emacs that bypasses straight.el by using Doom's CLI to export dependencies and then building them with Nix's emacsWithPackages. It provides a flake, overlay, Home Manager module, and a set of Nix expressions to build a fully reproducible Doom Emacs configuration with all dependencies pinned via Nix. The architecture consists of multiple steps: extracting package requirements from Doom via a Elisp script, applying Doom's pins to emacs-overlay packages, handling missing packages with IFD-based dependency detection, generating a Doom profile and profile loader, and finally wrapping the Emacs binary. The project features extensive CI/CD, automated daily flake updates, and a Cachix cache. It demonstrates sophisticated Nix patterns including IFD, fetchTree, structured overrides, and Emacs Lisp scripting within Nix builds.
God mode is an Emacs minor mode that enables modal editing by allowing users to enter Emacs commands without modifier keys. It works by remapping keys: by default, keys are interpreted with the Control modifier (C-), with 'g' for Meta (M-) and 'G' for Control-Meta (C-M-). The package includes features like a literal key (SPACE by default) to temporarily disable remapping, support for digit and universal arguments, and integration with isearch via a separate extension. The architecture uses Emacs' keymap system extensively with buffer-local and global state management, hooks for extensibility, and sophisticated key sequence lookup with fallback mechanisms.
envrc.el is an Emacs Lisp package that provides buffer-local environment variable management using the direnv tool. It implements a global minor mode (`envrc-global-mode`) that enables a local minor mode (`envrc-mode`) in every buffer, which sets buffer-local `process-environment`, `exec-path`, and related variables based on the nearest `.envrc` file. The package caches direnv results per directory, supports asynchronous direnv execution with configurable blocking behavior, and advises several Emacs shell commands (e.g., `shell-command`, `async-shell-command`, `org-babel-eval`) to propagate the local environment into temporary buffers. It also includes TRAMP support for remote files, a major mode for editing `.envrc` files, and a comprehensive test suite. The architecture is a single-file Emacs package with clean separation of concerns: environment detection, direnv process management, result caching, and application to buffer-local state. The code demonstrates advanced Emacs Lisp patterns including minor modes, process filters and sentinels, advice, and buffer-local variable management.
org-modern is an Emacs Lisp package that provides a modern visual style for Org mode buffers. It uses font-lock keywords and text properties to prettify headlines, tables, source blocks, timestamps, tags, TODO keywords, priorities, checkboxes, lists, progress bars, footnotes, internal/radio targets, horizontal rules, block names, and block fringes. The package is implemented as a single-file minor mode (`org-modern-mode`) with a global variant (`global-org-modern-mode`) and an agenda styling function (`org-modern-agenda`). It relies on Emacs 29.1, Org 9.6, and the Compat library. The code is well-structured, extensively customizable via defcustom options, and follows modern Emacs Lisp conventions. It does not contain reusable components outside the Org mode context, but the implementation demonstrates high craftsmanship in leveraging Emacs' font-lock and text property systems for UI styling.
Org-fc is a spaced repetition system implemented as an Emacs package for org-mode. It allows users to mark org-mode headlines as flashcards and review them using spaced repetition algorithms (SM2 or FSRS). The system features multiple card types (normal, double, text-input, cloze, vocab), efficient indexing via AWK scripts with caching, a dashboard for statistics, and optional extensions like audio playback and key-binding hints. The architecture is modular with clear separation between core functionality, review logic, card types, spacing algorithms, and utilities.
Valign.el is a single-file Emacs Lisp package that provides pixel-perfect visual alignment for tables in Org mode, Markdown, and table.el on GUI Emacs. It handles variable-pitch fonts, CJK characters, and images without altering the underlying text-based alignment. The core mechanism uses Emacs' display text properties and overlays to stretch spaces to calculated pixel positions, ensuring columns align correctly regardless of font metrics. The architecture is a self-contained module with generic methods (`cl-defmethod`) for different table types (Org, Markdown, table.el). The main entry point is the `valign-mode` minor mode, which hooks into `jit-lock-functions` to automatically realign tables during fontification. It also provides `valign-table` for manual alignment. The package advises several Org and Markdown functions to trigger realignment after edits, outline cycling, or text scaling. Key data flows: On fontification, `valign-region` scans for table delimiters, then for each table it calculates column widths by measuring pixel widths of cell contents, determines column alignment (left/right), and applies display properties to align cells. It also handles separator rows and fancy bar rendering. The package has no external dependencies beyond built-in Emacs libraries (`cl-lib`, `pcase`, `cl-generic`). The code demonstrates strong Emacs Lisp craftsmanship with clear separation of concerns, robust error handling, and performance considerations (e.g., skipping alignment after self-insert commands, limiting table size). It is a well-maintained, production-quality package available on GNU ELPA.
Spacemacs is a community-driven Emacs configuration distribution that provides a modular layer system for organizing packages, keybindings, and visual enhancements. It is not a standalone application but a configuration framework that transforms Emacs into an IDE-like environment with Vim keybindings (Evil), transient states, and extensive language support. The architecture is built around a core layer system: each layer (e.g., +lang/python, +tools/lsp) contains packages.el, config.el, funcs.el, and README.org, following a consistent pattern. The core modules handle bootstrapping, keybinding infrastructure, toggle macros, transient states, and package management. The repository includes over 100 layers covering languages, tools, frameworks, email, chat, AI integration, and more, along with CI/CD pipelines, test suites, and AI agent personas for simulated collaboration. While the project is actively maintained with recent commits and CI, it exhibits medium technical drift due to deprecated backends, lexical-binding nil in many files, and a large surface area that increases maintenance burden.
emacs-libvterm is a terminal emulator package for GNU Emacs, implemented as a hybrid of a C dynamic module and an Emacs Lisp package. The C module (vterm-module.c, elisp.c, utf8.c) wraps libvterm and exposes a small API (vterm--new, vterm--update, vterm--redraw, vterm--write-input, vterm--set-size, etc.) to Elisp. The Elisp side (vterm.el) provides the user-facing commands (vterm, vterm-other-window), manages the pty-backed shell process, defines keybindings, and implements copy mode, directory/prompt tracking, TRAMP support, and bookmarks. The module renders terminal cells into the Emacs buffer as text with font-lock face properties, batching runs of cells with identical attributes for performance. Data flows are bidirectional: keystrokes go from Emacs keybindings through vterm--update into the C term_process_key handler, which translates them into libvterm keyboard events and flushes resulting output bytes back to the pty. Shell output arrives via the process filter vterm--filter, which handles partial multibyte characters split across chunks, feeds bytes into libvterm, and triggers damage-based invalidation. The redraw pipeline (term_redraw, refresh_scrollback, refresh_screen, refresh_lines) maintains a scrollback ring buffer with per-line metadata (working directory, prompt column) that survives window resizes and reflow. OSC 51 escape sequences from the shell drive directory tracking, prompt detection, and whitelisted Elisp evaluation via vterm-eval-cmds. Notable engineering: the scrollback ring buffer with per-line metadata and resize handling, the batched cell rendering with text-property coalescing, and the clean separation between the Emacs API bridge (elisp.c) and terminal logic. The codebase carries compatibility shims for old libvterm versions (VTermStringFragment, VTermSelectionMask, sb_clear, reflow) and a dead Travis CI config targeting Emacs 25.3/26.1, indicating medium technical drift despite active maintenance. The term_process_key function is a monolithic if-else chain, and the CMake feature detection uses grep on headers, but overall the code is well-structured and battle-tested.
quickrun.el is an Emacs Lisp package that provides a quick and convenient way to execute the current buffer's content using the appropriate interpreter or compiler. It automatically detects the programming language based on file extension or major mode, then runs the corresponding command (e.g., python, gcc, node) with the buffer content as input. The package supports a wide range of languages, including compiled languages (C, C++, Java, Go), scripting languages (Python, Ruby, Perl), and markup languages (Markdown, HAML). It offers multiple execution modes: standard run, compile-only, shell (for interactive programs), region execution, and argument passing. Output can be directed to a dedicated *quickrun* buffer with ANSI color support, or to files, variables, browsers, or multiple destinations via a pluggable outputter system. The architecture is monolithic, with all functionality contained in a single Emacs Lisp file, but it provides a clean extension API via `quickrun-add-command` and `quickrun-set-default` for adding custom language support. The package is well-maintained, with active development and CI testing across multiple Emacs versions and platforms.
es-mode is an Emacs major mode for editing and executing Elasticsearch queries. It provides syntax highlighting, indentation, and keybindings for interacting with Elasticsearch clusters directly from Emacs buffers. The package includes features such as executing requests with C-c C-c, navigating between requests, copying requests as curl commands, an Elasticsearch Command Center for cluster monitoring, org-babel support for embedding queries in org-mode documents, and an interactive ESQL mode for Elasticsearch's ES|QL language. The architecture follows standard Emacs package conventions with several modular components: es-mode.el provides the core editing functionality, es-cc.el implements a monitoring dashboard, es-copyas.el handles request copying, es-esql.el offers an interactive ESQL interface, and ob-elasticsearch.el enables org-babel integration. The mode communicates with Elasticsearch using HTTP requests via the request library, displaying results in separate buffers with syntax highlighting and optional jq processing. Key strengths include thoughtful integration with Emacs workflows (company-mode completion, proper indentation, hook systems), robust error handling for network requests, and useful features like variable substitution in org-babel blocks and historical metric visualization in the command center. The code demonstrates solid Emacs Lisp craftsmanship with appropriate use of buffers, hooks, and asynchronous operations.
Smartparens is a mature Emacs minor mode for intelligent handling of parentheses, brackets, quotes, and other delimiters. It provides automatic pair insertion, wrapping, slurping/barfing (like Paredit), navigation by balanced expressions, and a strict mode that enforces structural balance. The core functionality is implemented in `smartparens.el`, with language-specific support modules for over 20 major modes (Python, Ruby, Rust, LaTeX, Clojure, etc.) that define custom pairs, skip-match predicates, and context-sensitive actions. The architecture is modular: the core exports a pair definition system (`sp-pair`, `sp-local-pair`) with fine-grained action hooks, context predicates, and prefix/suffix handling, while each language module registers its own configurations. The package is heavily customizable via `defcustom` and exposes interactive commands for everyday editing. The test suite is extensive, with over 60 test files using ERT and a custom macro framework that makes writing buffer-level behavior tests concise. The codebase demonstrates solid Emacs Lisp craftsmanship, with thoughtful use of macros, memoization, and backward-compatibility hacks. However, it shows signs of accumulated complexity, with some deprecated aliases, `defadvice` usage, and version-conditional code. The CI pipeline covers multiple Emacs versions and runs byte-compilation checks, indicating ongoing maintenance despite these legacy patterns. This is a well-known, actively developed package relied on by thousands of users. Its primary value is as an Emacs library, though patterns like the pair configuration system and test helper macros could inspire similar designs in other editor extensions or text-processing tools.
This repository contains a build toolchain for compiling tree-sitter grammar dynamic libraries (.so/.dylib/.dll) for use with Emacs 29+. The core is a Python CLI (`langman.py`) that wraps shell scripts (`build.sh` and `batch.sh`) to clone, compile, and install tree-sitter grammars from GitHub. It supports versioned builds (via git tags) with caching, cross-platform extended attribute versioning, and parallel builds. The architecture is a simple CLI application with separate commands for building, installing, and querying versions. The codebase is well-structured, includes unit and end-to-end tests, and demonstrates clean separation of concerns between the Python frontend and the shell-based build logic. The tool is practical for Emacs users who need a streamlined way to manage tree-sitter language grammars.
This repository provides an Emacs package that implements bash completion within Emacs shell buffers and command prompts. It works by spawning or reusing a bash process to generate completions via `compgen`, respecting the user's bash configuration including aliases, functions, and programmable completion. The package handles edge cases like quoted strings, redirections, and colon-separated variables, and works with TRAMP for remote shells. The architecture is centered around a single Emacs Lisp file that defines functions for parsing shell commands, communicating with bash processes, and formatting completion results. Key entry points include `bash-completion-setup` for initialization and `bash-completion-dynamic-complete` for integration with Emacs' completion system.
This is an Emacs major mode for managing the password-store (pass) keychain. It provides a directory-tree buffer listing password entries and directories, with keybindings to copy passwords, usernames, and URLs to the kill ring, edit, rename, delete, insert entries, and browse URLs. The package integrates with password-store-otp for two-factor authentication, displaying OTP tokens and countdown timers in entry view buffers. The architecture is a single-file Emacs Lisp library defining two major modes: `pass-mode` for the main store buffer and `pass-view-mode` for viewing individual encrypted files. It relies on external Emacs packages `password-store`, `password-store-otp`, and `f`, and ultimately the system `pass` CLI. The code is well-structured, follows Emacs Lisp conventions, uses macros for common patterns, and provides proper configuration options. However, the test suite is essentially empty, which limits confidence in long-term stability. The package is published on MELPA and integrates with common Emacs workflows, making it a practical tool for password management within Emacs.
This repository is a personal Emacs configuration and extension collection ('lazycat-emacs') by Andy Stewart, not a standalone application or service. It is organized as a modular Emacs Lisp setup: site-start.el bootstraps the load path, site-lisp/config/init.el loads per-feature init-*.el files covering languages, UI, AI assistants, LSP, IRC, email, and window management. The bulk of the code lives in site-lisp/extensions/lazycat/, a large grab-bag of self-contained Emacs Lisp utilities and minor modes, plus vendored third-party packages (SLIME, magit-section, doxymacs, ghc-mod, ruby-tools) and a comprehensive yasnippet snippet collection. It also bundles StarDict dictionary files and tree-sitter grammar binaries for offline lookup and modern syntax highlighting.
Elpy is an Emacs minor mode that provides a full-featured Python IDE within Emacs. The Python backend (elpy/ directory) implements a JSON-RPC server over stdin/stdout, using Jedi for static analysis (completions, definitions, calltips, refactoring) and external tools for formatting (autopep8, yapf, black) and linting (flake8). The Emacs Lisp frontend (elpy.el and related .el files) defines the minor mode, keymaps, modules for company-mode, eldoc, flymake, yasnippet, pyvenv, and more. The architecture is modular: each feature (completion, folding, multiedit, testing, debugging) is encapsulated in a module that can be enabled/disabled. The project is currently unmaintained with high technical drift due to dependency on evolving Jedi API and deprecated Emacs constructs.
This repository is a community-driven curated list (awesome list) of Emacs packages, utilities, and libraries. It is not a software application or data pipeline; it is a documentation resource. The main content is a single README.org file that categorizes hundreds of Emacs-related projects with links and brief descriptions. The repository includes a CI workflow that validates the table of contents and checks for broken links. It serves as a reference for Emacs users seeking packages for various purposes such as editing, programming, theming, and integration.
This repository provides gocode, an autocompletion daemon for the Go programming language. It operates as a client-server system where editors send source code and cursor position to a caching daemon, which returns context-sensitive completion candidates based on an internal type inference engine and package cache. The codebase includes robust parsers for compiled Go package archives (text, binary, indexed binary formats), a sophisticated token-based expression extractor for cursor context, and a config management system. However, the project is explicitly deprecated in favor of gopls, has not seen recent maintenance, and relies on outdated Go versions and build constraints. Its value now is primarily historical or as a reference for implementing basic Go completion in editors.