Skip to content
wimgoossens-devPublic

About

Reimagined version of emacs that aims to solve some of the current issues and wants to prolong its life with at least another 40 years.

Topics

Resources

Stars

0 stars

Watchers

0 watching

Forks

Latest commit

 

History

2 Commits

Folders and files

NameName
Last commit message
Last commit date
 
 
 
 

Repository files navigation

vmacs

A modern, highly performant reimagining of the classic Emacs platform. vmacs ends the editor wars by establishing modal editing (vim keybinds aka evil-mode) as the immutable baseline standard rather than an optional configuration plugin.

It strips away decades of historical baggage, replacing legacy text rendering engines and virtual terminals with a cutting-edge, hybrid architecture optimized for modern display protocols, instant execution, and an enhanced, data-driven Org-mode.

Note

This README serves as a public architectural blueprint and introductory overview. The actual source code development, issue tracking, and roadmap discussions will proudly be hosted on Codeberg.


🛠️ The Architecture & Tech Stack

vmacs splits its responsibilities across three distinct computing layers — Core Engine, Dynamic Extension, and User Application Space to eliminate the structural bottlenecks of traditional monolithic editors.

🏢 Component Layering Overview

  • 🎛️ User Interface & REPL Space — Clojure
    User-facing application space, package ecosystems, rich plugin management, and interactive Org UI frameworks.

  • ⚡ Dynamic Extension Pipeline — Scheme / LuaJIT
    Instant system hooks, fast automation macros, runtime keymap manipulation, and direct interfaces with local script configs.

  • ⚙️ Core Engine Room — Zig
    Bare-metal buffer state management, high-performance piece-tables, hardware-accelerated rendering pipelines, and display server I/O loops.


1. Zig: The Engine Room (Core & Memory Layout)

  • Why: Traditional Emacs relies on a massive, legacy C core. vmacs leverages Zig to manage raw text-buffer structures (using highly optimized piece-tables and gap-buffers), memory allocation, and direct interfaces to graphics pipelines.
  • How: Zig provides bare-metal, C-equivalent execution speeds with modern safety primitives. It acts as the high-performance compiled binary that boots the system, handles low-level file I/O, and runs the main event loops.

2. Scheme & LuaJIT: The Dynamic Extension Pipeline

  • Why: Code customization requires a language that can change its execution structures dynamically without restarting the application. This layer manages quick scripting hacks, dynamic system hooks, and configuration pipelines.
  • How:
    • GNU Guile Scheme: Provides a highly integrated Lisp-1 standard environment. Its inclusion ensures that vmacs natively communicates with structural system configurations like GNU Guix channels [GNU Guix].
    • LuaJIT: Integrated as a specialized communication engine running alongside Scheme, specifically tasked with speaking natively to the Neovim API and plugin ecosystem at raw compiled speeds.

3. Clojure: The User Interface & Rich Application Space

  • Why: Standard Scheme is beautiful for system scripting, but its ecosystem lacks heavy application frameworks. Clojure provides immutable data-driven structures and instant access to rich development library ecosystems.
  • How: Clojure manages the high-level interactive runtime environment. Complex extensions, package managers, git interfaces, and the user-facing framework layers are built in Clojure, giving developers an elite, modern REPL experience.

🧩 Native Component Integrations

Rather than writing terminal wrappers or inaccurate software emulations from scratch, vmacs embeds production-ready, industry-standard engines directly into its frame pipeline.

Headless Neovim (Native Modal Processing)

Instead of simulating Vim keybindings over an Emacs text engine, vmacs spawns a real, headless background instance of Neovim using its fast RPC (Remote Procedure Call) protocol.

  • The Workflow: vmacs controls the window management, themes, and UI rendering, but the actual text mutations, macros, and register structures are calculated natively by the Neovim engine.
  • Result: 100% bug-free Vim modal execution out of the box.

Embedded Ghostty (GPU Terminal Multiplexing)

vmacs completely bypasses slow, old virtual terminal configurations (vterm) by linking directly to Mitchell Hashimoto's Ghostty core (libghostty-vt) via native binary compilation.

  • The Workflow: Ghostty runs natively inside vmacs frame buffers, utilizing your GPU for hardware-accelerated text rendering and smooth scrolling.
  • Result: Native terminal multiplexing capabilities. You can split panes (:vsplit), create tabs, and run heavy CLI programs at 60 FPS while keeping access to your Lisp-space shortcuts.

🖥️ The Window Management Core: EWM (Emacs Window Manager)

vmacs takes the absolute structural convergence of your workspace to its logical conclusion through EWM (Emacs Window Manager). Rather than relying on external composers or separate desktop suites, vmacs is your graphical display controller and standalone operating environment.

  • The Paradigm: Your Linux kernel boots directly into vmacs. EWM intercepts all system-level window mappings and display pipelines, transforming every process on your machine into an addressable Lisp structure.
  • Native App Adoption: External third-party applications (like web browsers or graphical media utilities) are adopted directly by EWM and rendered seamlessly as raw workspace frames.
  • The Guix Ecosystem Advantage: On a GNU Guix System, this is the ultimate desktop architecture [GNU Guix]. Your hardware drivers, system daemons, system configurations, and desktop tiling layouts are declared under a single, unified pipeline of Guile Scheme code [GNU Guix]. Your entire operating system becomes one beautifully integrated, hackable machine.

📝 Enhanced Org-Mode

vmacs targets Org-mode as a core application tier rather than a standard text-formatting major mode. By leveraging Clojure's immutable data processing and Zig's fast parsing capabilities, vmacs elevates your organizational workflows:

  • Data-Driven Outlines: Org documents are treated as structural, interactive ASTs (Abstract Syntax Trees) in Clojure. You can query, sort, and transform your task schedules or nested trees instantly using data structures rather than running slow regex string searches.
  • Blazing Fast Agenda Views: Zig indexes, parses, and caches large directories of .org files in the background, rendering complex agenda overviews, calendar timelines, and tag searches in milliseconds.
  • Modern Interactive Babel: Code blocks inside your documents communicate natively with the embedded Clojure/Scheme REPL engines, enabling seamless data streaming between your notes and your active development states.

🤝 Collaboration & Contribution

vmacs is currently in a prototype phase and under heavy architectural design. We are actively seeking mad scientists, systems hackers, and functional programming enthusiasts to help shape the foundation of this platform.

We are looking for collaborators with expertise or interest in:

  • Zig: Designing high-throughput text buffer architectures (piece-tables) and direct display engine bindings.
  • GNU Guile / LuaJIT: Building the embedded macro engines and defining foreign function interfaces (FFI) for seamless Neovim bridge control.
  • Clojure: Architecting user-space application state, REPL multiplexing, and immutable data design for Org-mode.
  • Systems Hacking: Implementing the low-level window capture and client-adoption pipeline for EWM.

If you want to help build a truly unified, hacker-first text operating system, please jump over to our development space on Codeberg to open an issue, start a discussion thread, or coordinate with the core architecture team!

About

Reimagined version of emacs that aims to solve some of the current issues and wants to prolong its life with at least another 40 years.

Topics

Resources

Stars

0 stars

Watchers

0 watching

Forks

Releases

Packages

Contributors